Break dependency between ash::DisplayManager and ash::ScreenAsh

ash/display/display_manager.cc

 // Copyright (c) 2012 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 "ash/display/display_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/common/ash_switches.h"
 #include "ash/display/display_util.h"
-#include "ash/display/screen_ash.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 21 matching lines @@
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 namespace ash {
 
 namespace {
 
-// We need to keep this in order for unittests to tell if
-// the object in display::Screen::GetScreenByType is for shutdown.
-display::Screen* screen_for_shutdown = nullptr;
-
 // The number of pixels to overlap between the primary and secondary displays,
 // in case that the offset value is too large.
 const int kMinimumOverlapForInvalidOffset = 100;
 
 struct DisplaySortFunctor {
   bool operator()(const display::Display& a, const display::Display& b) {
     return display::CompareDisplayIds(a.id(), b.id());
   }
 };
 
@@ skipping 50 matching lines @@
 }
 
 }  // namespace
 
 using std::string;
 using std::vector;
 
 // static
 int64_t DisplayManager::kUnifiedDisplayId = -10;
 
-DisplayManager::DisplayManager()
+DisplayManager::DisplayManager(std::unique_ptr<display::Screen> screen)
     : delegate_(nullptr),
-      screen_(new ScreenAsh),
+      screen_(std::move(screen)),
       layout_store_(new display::DisplayLayoutStore),
       first_display_id_(display::Display::kInvalidDisplayID),
       num_connected_displays_(0),
       force_bounds_changed_(false),
       change_display_upon_host_resize_(false),
       multi_display_mode_(EXTENDED),
       current_default_multi_display_mode_(EXTENDED),
       mirroring_display_id_(display::Display::kInvalidDisplayID),
       registered_internal_display_rotation_lock_(false),
       registered_internal_display_rotation_(display::Display::ROTATE_0),
       unified_desktop_enabled_(false),
       weak_ptr_factory_(this) {
 #if defined(OS_CHROMEOS)
   change_display_upon_host_resize_ = !base::SysInfo::IsRunningOnChromeOS();
   unified_desktop_enabled_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kAshEnableUnifiedDesktop);
 #endif
-  display::Screen* current = display::Screen::GetScreen();
-  // If there is no native, or the native was for shutdown,
-  // use ash's screen.
-  if (!current || current == screen_for_shutdown)
-    display::Screen::SetScreenInstance(screen_.get());
 }
 
 DisplayManager::~DisplayManager() {
 #if defined(OS_CHROMEOS)
   // Reset the font params.
   gfx::SetFontRenderParamsDeviceScaleFactor(1.0f);
 #endif
 }
 
 bool DisplayManager::InitFromCommandLine() {
@@ skipping 88 matching lines @@
 
   layout_store_->RegisterLayoutForDisplayIdList(list, std::move(layout));
   if (delegate_)
     delegate_->PreDisplayConfigurationChange(false);
 
   // TODO(oshima): Call UpdateDisplays instead.
   std::vector<int64_t> updated_ids;
   ApplyDisplayLayout(GetCurrentDisplayLayout(), &active_display_list_,
                      &updated_ids);
   for (int64_t id : updated_ids) {
-    screen_->NotifyMetricsChanged(
+    NotifyMetricsChanged(
         GetDisplayForId(id),
         display::DisplayObserver::DISPLAY_METRIC_BOUNDS |
             display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   }
 
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 }
 
 const display::Display& DisplayManager::GetDisplayForId(int64_t id) const {
@@ skipping 10 matching lines @@
 }
 
 bool DisplayManager::UpdateWorkAreaOfDisplay(int64_t display_id,
                                              const gfx::Insets& insets) {
   display::Display* display = FindDisplayForId(display_id);
   DCHECK(display);
   gfx::Rect old_work_area = display->work_area();
   display->UpdateWorkAreaFromInsets(insets);
   bool workarea_changed = old_work_area != display->work_area();
   if (workarea_changed) {
-    screen_->NotifyMetricsChanged(
-        *display, display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
+    NotifyMetricsChanged(*display,
+                         display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
   }
   return workarea_changed;
 }
 
 void DisplayManager::SetOverscanInsets(int64_t display_id,
                                        const gfx::Insets& insets_in_dip) {
   bool update = false;
   DisplayInfoList display_info_list;
   for (const auto& display : active_display_list_) {
     display::ManagedDisplayInfo info = GetDisplayInfo(display.id());
@@ skipping 490 matching lines @@
   base::AutoReset<bool> resetter(&change_display_upon_host_resize_, false);
 
   int active_display_list_size = active_display_list_.size();
   is_updating_display_list_ = true;
   // Temporarily add displays to be removed because display object
   // being removed are accessed during shutting down the root.
   active_display_list_.insert(active_display_list_.end(),
                               removed_displays.begin(), removed_displays.end());
 
   for (const auto& display : removed_displays)
-    screen_->NotifyDisplayRemoved(display);
+    NotifyDisplayRemoved(display);
 
   for (size_t index : added_display_indices)
-    screen_->NotifyDisplayAdded(active_display_list_[index]);
+    NotifyDisplayAdded(active_display_list_[index]);
 
   active_display_list_.resize(active_display_list_size);
   is_updating_display_list_ = false;
 
   bool notify_primary_change =
       delegate_ ? old_primary.id() != screen_->GetPrimaryDisplay().id() : false;
 
   for (std::map<size_t, uint32_t>::iterator iter = display_changes.begin();
        iter != display_changes.end(); ++iter) {
     uint32_t metrics = iter->second;
     const display::Display& updated_display = active_display_list_[iter->first];
 
     if (notify_primary_change &&
         updated_display.id() == screen_->GetPrimaryDisplay().id()) {
       metrics |= display::DisplayObserver::DISPLAY_METRIC_PRIMARY;
       notify_primary_change = false;
     }
-    screen_->NotifyMetricsChanged(updated_display, metrics);
+    NotifyMetricsChanged(updated_display, metrics);
   }
 
   if (notify_primary_change) {
     // This happens when a primary display has moved to anther display without
     // bounds change.
     const display::Display& primary = screen_->GetPrimaryDisplay();
     if (primary.id() != old_primary.id()) {
       uint32_t metrics = display::DisplayObserver::DISPLAY_METRIC_PRIMARY;
       if (primary.size() != old_primary.size()) {
         metrics |= (display::DisplayObserver::DISPLAY_METRIC_BOUNDS |
                     display::DisplayObserver::DISPLAY_METRIC_WORK_AREA);
       }
       if (primary.device_scale_factor() != old_primary.device_scale_factor())
         metrics |= display::DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR;
 
-      screen_->NotifyMetricsChanged(primary, metrics);
+      NotifyMetricsChanged(primary, metrics);
     }
   }
 
   if (delegate_)
     delegate_->PostDisplayConfigurationChange();
 
 #if defined(USE_X11) && defined(OS_CHROMEOS)
   if (!display_changes.empty() && base::SysInfo::IsRunningOnChromeOS())
     ui::ClearX11DefaultRootWindow();
 #endif
@@ skipping 185 matching lines @@
 
 bool DisplayManager::UpdateDisplayBounds(int64_t display_id,
                                          const gfx::Rect& new_bounds) {
   if (change_display_upon_host_resize_) {
     display_info_[display_id].SetBounds(new_bounds);
     // Don't notify observers if the mirrored window has changed.
     if (software_mirroring_enabled() && mirroring_display_id_ == display_id)
       return false;
     display::Display* display = FindDisplayForId(display_id);
     display->SetSize(display_info_[display_id].size_in_pixel());
-    screen_->NotifyMetricsChanged(
-        *display, display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
+    NotifyMetricsChanged(*display,
+                         display::DisplayObserver::DISPLAY_METRIC_BOUNDS);
     return true;
   }
   return false;
 }
 
 void DisplayManager::CreateMirrorWindowAsyncIfAny() {
   // Do not post a task if the software mirroring doesn't exist, or
   // during initialization when compositor's init task isn't posted yet.
   // ash::Shell::Init() will call this after the compositor is initialized.
   if (software_mirroring_display_list_.empty() || !delegate_)
     return;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&DisplayManager::CreateMirrorWindowIfAny,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
-void DisplayManager::CreateScreenForShutdown() const {
-  delete screen_for_shutdown;
-  screen_for_shutdown = screen_->CloneForShutdown();
-  display::Screen::SetScreenInstance(screen_for_shutdown);
-}
-
 void DisplayManager::UpdateInternalManagedDisplayModeListForTest() {
   if (!display::Display::HasInternalDisplay() ||
       display_info_.count(display::Display::InternalDisplayId()) == 0)
     return;
   display::ManagedDisplayInfo* info =
       &display_info_[display::Display::InternalDisplayId()];
   SetInternalManagedDisplayModeList(info);
 }
 
 bool DisplayManager::ZoomInternalDisplay(bool up) {
@@ skipping 305 matching lines @@
                                         std::vector<int64_t>* updated_ids) {
   layout.ApplyToDisplayList(display_list, updated_ids,
                             kMinimumOverlapForInvalidOffset);
 }
 
 void DisplayManager::RunPendingTasksForTest() {
   if (!software_mirroring_display_list_.empty())
     base::RunLoop().RunUntilIdle();
 }
 
+void DisplayManager::NotifyMetricsChanged(const display::Display& display,
+                                          uint32_t metrics) {
+  FOR_EACH_OBSERVER(display::DisplayObserver, observers_,
+                    OnDisplayMetricsChanged(display, metrics));
+}
+
+void DisplayManager::NotifyDisplayAdded(const display::Display& display) {
+  FOR_EACH_OBSERVER(display::DisplayObserver, observers_,
+                    OnDisplayAdded(display));
+}
+
+void DisplayManager::NotifyDisplayRemoved(const display::Display& display) {
+  FOR_EACH_OBSERVER(display::DisplayObserver, observers_,
+                    OnDisplayRemoved(display));
+}
+
+void DisplayManager::AddObserver(display::DisplayObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void DisplayManager::RemoveObserver(display::DisplayObserver* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 }  // namespace ash