Revert "Postpone color mode change until after boot animation"

am: 2924d01304

Change-Id: If182308e0602e3e5af0998698f0e428f7c3ff18d

diff --cc services/surfaceflinger/SurfaceFlinger.cpp
index 4aaa8c0,8ed6686..6661326
--- 1/services/surfaceflinger/SurfaceFlinger.cpp
--- 2/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@@ -569,48 -545,50 +559,48 @@@ void SurfaceFlinger::init() 
      ALOGI(  "SurfaceFlinger's main thread ready to run. "
              "Initializing graphics H/W...");
  
-     ALOGI("Phase offset NS: %" PRId64 "", vsyncPhaseOffsetNs);
+     ALOGI("Phase offest NS: %" PRId64 "", vsyncPhaseOffsetNs);
  
 -    { // Autolock scope
 -        Mutex::Autolock _l(mStateLock);
 +    Mutex::Autolock _l(mStateLock);
  
 -        // initialize EGL for the default display
 -        mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 -        eglInitialize(mEGLDisplay, NULL, NULL);
 -
 -        // start the EventThread
 -        sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
 -                vsyncPhaseOffsetNs, true, "app");
 -        mEventThread = new EventThread(vsyncSrc, *this, false);
 -        sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
 -                sfVsyncPhaseOffsetNs, true, "sf");
 -        mSFEventThread = new EventThread(sfVsyncSrc, *this, true);
 -        mEventQueue.setEventThread(mSFEventThread);
 +    // initialize EGL for the default display
 +    mEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 +    eglInitialize(mEGLDisplay, NULL, NULL);
  
 -        // set EventThread and SFEventThread to SCHED_FIFO to minimize jitter
 -        struct sched_param param = {0};
 -        param.sched_priority = 2;
 -        if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, &param) != 0) {
 -            ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
 -        }
 -        if (sched_setscheduler(mEventThread->getTid(), SCHED_FIFO, &param) != 0) {
 -            ALOGE("Couldn't set SCHED_FIFO for EventThread");
 -        }
 +    // start the EventThread
 +    sp<VSyncSource> vsyncSrc = new DispSyncSource(&mPrimaryDispSync,
 +            vsyncPhaseOffsetNs, true, "app");
 +    mEventThread = new EventThread(vsyncSrc, *this, false);
 +    sp<VSyncSource> sfVsyncSrc = new DispSyncSource(&mPrimaryDispSync,
 +            sfVsyncPhaseOffsetNs, true, "sf");
 +    mSFEventThread = new EventThread(sfVsyncSrc, *this, true);
 +    mEventQueue.setEventThread(mSFEventThread);
  
 -        // Get a RenderEngine for the given display / config (can't fail)
 -        mRenderEngine = RenderEngine::create(mEGLDisplay,
 -                HAL_PIXEL_FORMAT_RGBA_8888,
 -                hasWideColorDisplay ? RenderEngine::WIDE_COLOR_SUPPORT : 0);
 +    // set EventThread and SFEventThread to SCHED_FIFO to minimize jitter
 +    struct sched_param param = {0};
 +    param.sched_priority = 2;
 +    if (sched_setscheduler(mSFEventThread->getTid(), SCHED_FIFO, &param) != 0) {
 +        ALOGE("Couldn't set SCHED_FIFO for SFEventThread");
 +    }
 +    if (sched_setscheduler(mEventThread->getTid(), SCHED_FIFO, &param) != 0) {
 +        ALOGE("Couldn't set SCHED_FIFO for EventThread");
      }
  
 -    // Drop the state lock while we initialize the hardware composer. We drop
 -    // the lock because on creation, it will call back into SurfaceFlinger to
 -    // initialize the primary display.
 -    LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
 -        "Starting with vr flinger active is not currently supported.");
 -    mRealHwc = new HWComposer(false);
 -    mHwc = mRealHwc;
 -    mHwc->setEventHandler(static_cast<HWComposer::EventHandler*>(this));
 +    // Get a RenderEngine for the given display / config (can't fail)
 +    mRenderEngine = RenderEngine::create(mEGLDisplay,
 +            HAL_PIXEL_FORMAT_RGBA_8888,
 +            hasWideColorDisplay ? RenderEngine::WIDE_COLOR_SUPPORT : 0);
  
 -    Mutex::Autolock _l(mStateLock);
 +    // retrieve the EGL context that was selected/created
 +    mEGLContext = mRenderEngine->getEGLContext();
 +
 +    LOG_ALWAYS_FATAL_IF(mEGLContext == EGL_NO_CONTEXT,
 +            "couldn't create EGLContext");
 +
 +    LOG_ALWAYS_FATAL_IF(mVrFlingerRequestsDisplay,
 +            "Starting with vr flinger active is not currently supported.");
 +    mHwc.reset(new HWComposer(false));
 +    mHwc->registerCallback(this, mComposerSequenceId);
  
      if (useVrFlinger) {
          auto vrFlingerRequestDisplayCallback = [this] (bool requestDisplay) {
@@@ -1231,51 -1214,34 +1221,55 @@@ void SurfaceFlinger::createDefaultDispl
                                               token, fbs, producer, mRenderEngine->getEGLConfig(),
                                               hasWideColorModes && hasWideColorDisplay);
      mDisplays.add(token, hw);
-     setActiveColorModeInternal(hw, HAL_COLOR_MODE_NATIVE);
+     android_color_mode defaultColorMode = HAL_COLOR_MODE_NATIVE;
+     if (hasWideColorModes && hasWideColorDisplay) {
+         defaultColorMode = HAL_COLOR_MODE_SRGB;
+     }
+     setActiveColorModeInternal(hw, defaultColorMode);
      hw->setCompositionDataSpace(HAL_DATASPACE_UNKNOWN);
 -}
  
 -void SurfaceFlinger::onHotplugReceived(HWComposer* composer, int32_t disp, bool connected) {
 -    ALOGV("onHotplugReceived(%d, %s)", disp, connected ? "true" : "false");
 +    // Add the primary display token to mDrawingState so we don't try to
 +    // recreate the DisplayDevice for the primary display.
 +    mDrawingState.displays.add(token, DisplayDeviceState(type, true));
  
 -    if (composer->isUsingVrComposer()) {
 -        // We handle initializing the primary display device for the VR
 -        // window manager hwc explicitly at the time of transition.
 -        if (disp != DisplayDevice::DISPLAY_PRIMARY) {
 -            ALOGE("External displays are not supported by the vr hardware composer.");
 +    // make the GLContext current so that we can create textures when creating
 +    // Layers (which may happens before we render something)
 +    hw->makeCurrent(mEGLDisplay, mEGLContext);
 +}
 +
 +void SurfaceFlinger::onHotplugReceived(int32_t sequenceId,
 +        hwc2_display_t display, HWC2::Connection connection,
 +        bool primaryDisplay) {
 +    ALOGV("onHotplugReceived(%d, %" PRIu64 ", %s, %s)",
 +          sequenceId, display,
 +          connection == HWC2::Connection::Connected ?
 +                  "connected" : "disconnected",
 +          primaryDisplay ? "primary" : "external");
 +
 +    // Only lock if we're not on the main thread. This function is normally
 +    // called on a hwbinder thread, but for the primary display it's called on
 +    // the main thread with the state lock already held, so don't attempt to
 +    // acquire it here.
 +    ConditionalLock lock(mStateLock,
 +            std::this_thread::get_id() != mMainThreadId);
 +
 +    if (primaryDisplay) {
 +        mHwc->onHotplug(display, connection);
 +        if (!mBuiltinDisplays[DisplayDevice::DISPLAY_PRIMARY].get()) {
 +            createBuiltinDisplayLocked(DisplayDevice::DISPLAY_PRIMARY);
          }
 -        return;
 -    }
 -
 -    if (disp == DisplayDevice::DISPLAY_PRIMARY) {
 -        Mutex::Autolock lock(mStateLock);
 -        createBuiltinDisplayLocked(DisplayDevice::DISPLAY_PRIMARY);
          createDefaultDisplayDevice();
      } else {
 +        if (sequenceId != mComposerSequenceId) {
 +            return;
 +        }
 +        if (mHwc->isUsingVrComposer()) {
 +            ALOGE("External displays are not supported by the vr hardware composer.");
 +            return;
 +        }
 +        mHwc->onHotplug(display, connection);
          auto type = DisplayDevice::DISPLAY_EXTERNAL;
 -        Mutex::Autolock _l(mStateLock);
 -        if (connected) {
 +        if (connection == HWC2::Connection::Connected) {
              createBuiltinDisplayLocked(type);
          } else {
              mCurrentState.displays.removeItem(mBuiltinDisplays[type]);