[Ozone-DRI] Add display observer

ui/ozone/platform/dri/screen_manager.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/ozone/platform/dri/screen_manager.h"
 
 #include <xf86drmMode.h>
 
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/point.h"
@@ skipping 47 matching lines @@
 }
 
 }  // namespace
 
 ScreenManager::ScreenManager(DriWrapper* dri,
                              ScanoutBufferGenerator* buffer_generator)
     : dri_(dri), buffer_generator_(buffer_generator) {
 }
 
 ScreenManager::~ScreenManager() {
+  DCHECK_EQ(0u, observers_.size());
 }
 
 void ScreenManager::AddDisplayController(DriWrapper* dri,
                                          uint32_t crtc,
                                          uint32_t connector) {
   HardwareDisplayControllers::iterator it = FindDisplayController(crtc);
   // TODO(dnicoara): Turn this into a DCHECK when async display configuration is
   // properly supported. (When there can't be a race between forcing initial
   // display configuration in ScreenManager and NativeDisplayDelegate creating
   // the display controllers.)
   if (it != controllers_.end()) {
     LOG(WARNING) << "Display controller (crtc=" << crtc << ") already present.";
     return;
   }
 
   controllers_.push_back(new HardwareDisplayController(
       scoped_ptr<CrtcController>(new CrtcController(dri, crtc, connector))));
 }
 
 void ScreenManager::RemoveDisplayController(uint32_t crtc) {
   HardwareDisplayControllers::iterator it = FindDisplayController(crtc);
   if (it != controllers_.end()) {
     bool is_mirrored = (*it)->IsMirrored();
     (*it)->RemoveCrtc(crtc);
-    if (!is_mirrored)
+    if (!is_mirrored) {
+      FOR_EACH_OBSERVER(DisplayChangeObserver, observers_,
+                        OnDisplayRemoved(*it));
       controllers_.erase(it);
+    }
   }
 }
 
 bool ScreenManager::ConfigureDisplayController(uint32_t crtc,
                                                uint32_t connector,
                                                const gfx::Point& origin,
                                                const drmModeModeInfo& mode) {
   gfx::Rect modeset_bounds(origin.x(), origin.y(), mode.hdisplay,
                            mode.vdisplay);
   HardwareDisplayControllers::iterator it = FindDisplayController(crtc);
   DCHECK(controllers_.end() != it) << "Display controller (crtc=" << crtc
                                    << ") doesn't exist.";
 
   HardwareDisplayController* controller = *it;
-  controller = *it;
   // If nothing changed just enable the controller. Note, we perform an exact
   // comparison on the mode since the refresh rate may have changed.
   if (SameMode(mode, controller->get_mode()) &&
       origin == controller->origin()) {
     if (controller->IsDisabled()) {
       HardwareDisplayControllers::iterator mirror =
           FindActiveDisplayControllerByLocation(modeset_bounds);
       // If there is an active controller at the same location then start mirror
       // mode.
       if (mirror != controllers_.end())
         return HandleMirrorMode(it, mirror, crtc, connector);
     }
 
+    FOR_EACH_OBSERVER(DisplayChangeObserver, observers_,
+                      OnDisplayChanged(controller));
     // Just re-enable the controller to re-use the current state.
     return controller->Enable();
   }
 
   // Either the mode or the location of the display changed, so exit mirror
   // mode and configure the display independently. If the caller still wants
   // mirror mode, subsequent calls configuring the other controllers will
   // restore mirror mode.
   if (controller->IsMirrored()) {
     controller = new HardwareDisplayController(controller->RemoveCrtc(crtc));
@@ skipping 20 matching lines @@
     }
 
     (*it)->Disable();
     return true;
   }
 
   LOG(ERROR) << "Failed to find display controller crtc=" << crtc;
   return false;
 }
 
-base::WeakPtr<HardwareDisplayController> ScreenManager::GetDisplayController(
+HardwareDisplayController* ScreenManager::GetDisplayController(
     const gfx::Rect& bounds) {
   // TODO(dnicoara): Remove hack once TestScreen uses a simple Ozone display
   // configuration reader and ScreenManager is called from there to create the
   // one display needed by the content_shell target.
   if (controllers_.empty())
     ForceInitializationOfPrimaryDisplay();
 
   HardwareDisplayControllers::iterator it =
       FindActiveDisplayControllerByLocation(bounds);
   if (it != controllers_.end())
-    return (*it)->AsWeakPtr();
+    return *it;
 
-  return base::WeakPtr<HardwareDisplayController>();
+  return nullptr;
+}
+
+void ScreenManager::AddObserver(DisplayChangeObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void ScreenManager::RemoveObserver(DisplayChangeObserver* observer) {
+  observers_.RemoveObserver(observer);
 }
 
 ScreenManager::HardwareDisplayControllers::iterator
 ScreenManager::FindDisplayController(uint32_t crtc) {
   for (HardwareDisplayControllers::iterator it = controllers_.begin();
        it != controllers_.end();
        ++it) {
     if ((*it)->HasCrtc(crtc))
       return it;
   }
@@ skipping 51 matching lines @@
     return false;
   }
 
   FillModesetBuffer(dri_, controller, buffer.get());
 
   if (!controller->Modeset(OverlayPlane(buffer), mode)) {
     LOG(ERROR) << "Failed to modeset controller";
     return false;
   }
 
+  FOR_EACH_OBSERVER(DisplayChangeObserver, observers_,
+                    OnDisplayChanged(controller));
   return true;
 }
 
 bool ScreenManager::HandleMirrorMode(
     HardwareDisplayControllers::iterator original,
     HardwareDisplayControllers::iterator mirror,
     uint32_t crtc,
     uint32_t connector) {
   (*mirror)->AddCrtc((*original)->RemoveCrtc(crtc));
   if ((*mirror)->Enable()) {
+    FOR_EACH_OBSERVER(DisplayChangeObserver, observers_,
+                      OnDisplayRemoved(*original));
+    FOR_EACH_OBSERVER(DisplayChangeObserver, observers_,
+                      OnDisplayChanged(*mirror));
     controllers_.erase(original);
     return true;
   }
 
   LOG(ERROR) << "Failed to switch to mirror mode";
 
   // When things go wrong revert back to the previous configuration since
   // it is expected that the configuration would not have changed if
   // things fail.
   (*original)->AddCrtc((*mirror)->RemoveCrtc(crtc));

[alexst (slow to review), 2015/01/12 18:49:10]

The expectation here is that the config is going to succeed and be the same as
it was last time, right?

[dnicoara, 2015/01/12 18:57:11]

Not necessarily. The enable operation may fail, but we're at least leaving the
CRTCs in the same state they were before this operation.

Theoretically this can fail and it wouldn't matter anyways since we were trying
to configure |original| and we're failing the configuration.

   (*original)->Enable();
   return false;
 }
 
 }  // namespace ui