Split //ui/display and create //ui/display/manager.

ui/display/manager/chromeos/display_configurator.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/display/chromeos/display_configurator.h"
+#include "ui/display/manager/chromeos/display_configurator.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
-#include "ui/display/chromeos/apply_content_protection_task.h"
-#include "ui/display/chromeos/display_layout_manager.h"
-#include "ui/display/chromeos/display_snapshot_virtual.h"
-#include "ui/display/chromeos/display_util.h"
-#include "ui/display/chromeos/update_display_configuration_task.h"
 #include "ui/display/display.h"
 #include "ui/display/display_switches.h"
+#include "ui/display/manager/chromeos/apply_content_protection_task.h"
+#include "ui/display/manager/chromeos/display_layout_manager.h"
+#include "ui/display/manager/chromeos/display_snapshot_virtual.h"
+#include "ui/display/manager/chromeos/display_util.h"
+#include "ui/display/manager/chromeos/update_display_configuration_task.h"
 #include "ui/display/types/display_mode.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/display/util/display_util.h"
 
 namespace ui {
 
 namespace {
 
 typedef std::vector<const DisplayMode*> DisplayModeList;
 
 // The EDID specification marks the top bit of the manufacturer id as reserved.
 const int16_t kReservedManufacturerID = static_cast<int16_t>(1 << 15);
 
 struct DisplayState {
   DisplaySnapshot* display = nullptr;  // Not owned.
 
   // User-selected mode for the display.
   const DisplayMode* selected_mode = nullptr;
 
   // Mode used when displaying the same desktop on multiple displays.
   const DisplayMode* mirror_mode = nullptr;
 };
 
-void DoNothing(bool status) {
-}
+void DoNothing(bool status) {}
 
 }  // namespace
 
 const int DisplayConfigurator::kSetDisplayPowerNoFlags = 0;
 const int DisplayConfigurator::kSetDisplayPowerForceProbe = 1 << 0;
-const int
-DisplayConfigurator::kSetDisplayPowerOnlyIfSingleInternalDisplay = 1 << 1;
+const int DisplayConfigurator::kSetDisplayPowerOnlyIfSingleInternalDisplay =
+    1 << 1;
 
 bool DisplayConfigurator::TestApi::TriggerConfigureTimeout() {
   if (configurator_->configure_timer_.IsRunning()) {
     configurator_->configure_timer_.user_task().Run();
     configurator_->configure_timer_.Stop();
     return true;
   } else {
     return false;
   }
 }
@@ skipping 53 matching lines @@
                       bool try_panel_fitting,
                       bool preserve_aspect) const;
 
   DisplayConfigurator* configurator_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(DisplayLayoutManagerImpl);
 };
 
 DisplayConfigurator::DisplayLayoutManagerImpl::DisplayLayoutManagerImpl(
     DisplayConfigurator* configurator)
-    : configurator_(configurator) {
-}
+    : configurator_(configurator) {}
 
-DisplayConfigurator::DisplayLayoutManagerImpl::~DisplayLayoutManagerImpl() {
-}
+DisplayConfigurator::DisplayLayoutManagerImpl::~DisplayLayoutManagerImpl() {}
 
 DisplayConfigurator::SoftwareMirroringController*
 DisplayConfigurator::DisplayLayoutManagerImpl::GetSoftwareMirroringController()
     const {
   return configurator_->mirroring_controller_;
 }
 
 DisplayConfigurator::StateController*
 DisplayConfigurator::DisplayLayoutManagerImpl::GetStateController() const {
   return configurator_->state_controller_;
@@ skipping 262 matching lines @@
       bool can_fit = internal_native_info->size().width() >=
                          external_mode->size().width() &&
                      internal_native_info->size().height() >=
                          external_mode->size().height() &&
                      !external_mode->is_interlaced();
       if (can_fit) {
         configurator_->native_display_delegate_->AddMode(
             *internal_display->display, external_mode.get());
         internal_display->display->add_mode(external_mode.get());
         internal_display->mirror_mode =
-          internal_display->display->modes().back().get();
+            internal_display->display->modes().back().get();
         external_display->mirror_mode = external_mode.get();
         return true;  // Mirror mode created.
       }
     }
   }
 
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 49 matching lines @@
       requested_power_state_(chromeos::DISPLAY_POWER_ALL_ON),
       pending_power_state_(chromeos::DISPLAY_POWER_ALL_ON),
       has_pending_power_state_(false),
       pending_power_flags_(kSetDisplayPowerNoFlags),
       force_configure_(false),
       next_display_protection_client_id_(1),
       display_externally_controlled_(false),
       display_control_changing_(false),
       displays_suspended_(false),
       layout_manager_(new DisplayLayoutManagerImpl(this)),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 DisplayConfigurator::~DisplayConfigurator() {
   if (native_display_delegate_)
     native_display_delegate_->RemoveObserver(this);
 
   CallAndClearInProgressCallbacks(false);
   CallAndClearQueuedCallbacks(false);
 
   while (!query_protection_callbacks_.empty()) {
     query_protection_callbacks_.front().Run(QueryProtectionResponse());
@@ skipping 91 matching lines @@
 
   // Turn off the displays before releasing control since we're no longer using
   // them for output.
   SetDisplayPowerInternal(
       chromeos::DISPLAY_POWER_ALL_OFF, kSetDisplayPowerNoFlags,
       base::Bind(&DisplayConfigurator::SendRelinquishDisplayControl,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void DisplayConfigurator::SendRelinquishDisplayControl(
-    const DisplayControlCallback& callback, bool success) {
+    const DisplayControlCallback& callback,
+    bool success) {
   if (success) {
     // Set the flag early such that an incoming configuration event won't start
     // while we're releasing control of the displays.
     display_externally_controlled_ = true;
     native_display_delegate_->RelinquishDisplayControl(
         base::Bind(&DisplayConfigurator::OnDisplayControlRelinquished,
                    weak_ptr_factory_.GetWeakPtr(), callback));
   } else {
     display_control_changing_ = false;
     callback.Run(false);
@@ skipping 415 matching lines @@
 
   if (!ShouldRunConfigurationTask()) {
     LOG(ERROR) << "Called RunPendingConfiguration without any changes"
                   " requested";
     CallAndClearQueuedCallbacks(true);
     return;
   }
 
   configuration_task_.reset(new UpdateDisplayConfigurationTask(
       native_display_delegate_.get(), layout_manager_.get(),
-      requested_display_state_, pending_power_state_, pending_power_flags_,
-      0, force_configure_, base::Bind(&DisplayConfigurator::OnConfigured,
-                                      weak_ptr_factory_.GetWeakPtr())));
+      requested_display_state_, pending_power_state_, pending_power_flags_, 0,
+      force_configure_, base::Bind(&DisplayConfigurator::OnConfigured,
+                                   weak_ptr_factory_.GetWeakPtr())));
   configuration_task_->set_virtual_display_snapshots(
       virtual_display_snapshots_.get());
 
   // Reset the flags before running the task; otherwise it may end up scheduling
   // another configuration.
   force_configure_ = false;
   pending_power_flags_ = kSetDisplayPowerNoFlags;
   has_pending_power_state_ = false;
   requested_display_state_ = MULTIPLE_DISPLAY_STATE_INVALID;
 
@@ skipping 142 matching lines @@
   last_virtual_display_id_ = max_display_id & 0xff;
 
   return true;
 }
 
 bool DisplayConfigurator::IsDisplayOn() const {
   return current_power_state_ != chromeos::DISPLAY_POWER_ALL_OFF;
 }
 
 }  // namespace ui