Expand and split DisplayController mojom.

services/ui/display/platform_screen_ozone.cc

 // Copyright 2016 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 "services/ui/display/platform_screen_ozone.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 55 matching lines @@
   registry->AddInterface<mojom::DisplayController>(this);
 }
 
 void PlatformScreenOzone::Init(PlatformScreenDelegate* delegate) {
   DCHECK(delegate);
   delegate_ = delegate;
 
   std::unique_ptr<ui::NativeDisplayDelegate> native_display_delegate =
       ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate();
 
+  // The FakeDisplayController gives us a way to make the NativeDisplayDelegate
+  // pretend something display related has happened.
   if (!base::SysInfo::IsRunningOnChromeOS()) {
     fake_display_controller_ =
         native_display_delegate->GetFakeDisplayController();
   }
 
   // We want display configuration to happen even off device to keep the control
   // flow similar.
   display_configurator_.set_configure_display(true);
   display_configurator_.AddObserver(this);
   display_configurator_.Init(std::move(native_display_delegate), false);
@@ skipping 10 matching lines @@
     // that the display configuration has changed and the display will be gone.
     wait_for_display_config_update_ =
         fake_display_controller_->RemoveDisplay(iter->id);
   }
 }
 
 int64_t PlatformScreenOzone::GetPrimaryDisplayId() const {
   return primary_display_id_;
 }
 
-void PlatformScreenOzone::ToggleVirtualDisplay() {
+void PlatformScreenOzone::ToggleAddRemoveDisplay() {
   if (!fake_display_controller_ || wait_for_display_config_update_)
     return;
 
   if (cached_displays_.size() == 1) {
     const gfx::Size& pixel_size = cached_displays_[0].pixel_size;
     wait_for_display_config_update_ =
         fake_display_controller_->AddDisplay(pixel_size) !=
         Display::kInvalidDisplayID;
   } else if (cached_displays_.size() > 1) {
     wait_for_display_config_update_ =
         fake_display_controller_->RemoveDisplay(cached_displays_.back().id);
   } else {
     NOTREACHED();
   }
 }
 
+void PlatformScreenOzone::SwapPrimaryDisplay() {
+  const size_t num_displays = cached_displays_.size();
+  if (num_displays <= 1)
+    return;
+
+  // Find index of current primary display.
+  size_t primary_display_index = 0;
+  for (size_t i = 0; i < num_displays; i++) {
+    if (cached_displays_[i].id == primary_display_id_) {
+      primary_display_index = i;
+      break;
+    }
+  }
+
+  // Set next display index as primary, or loop back to first display if last.
+  if (primary_display_index + 1 == num_displays) {
+    primary_display_id_ = cached_displays_[0].id;
+  } else {
+    primary_display_id_ = cached_displays_[primary_display_index + 1].id;
+  }
+
+  // TODO(kylechar): Update ws::DisplayManager.
+}
+
+void PlatformScreenOzone::SetDisplayWorkArea(int64_t display_id,
+                                             const gfx::Size& size,
+                                             const gfx::Insets& insets) {
+  CachedDisplayIterator iter = GetCachedDisplayIterator(display_id);
+  if (iter == cached_displays_.end()) {
+    NOTREACHED() << display_id;
+    return;
+  }
+
+  DisplayInfo& display_info = *iter;
+  if (display_info.bounds.size() == size) {
+    // TODO(kylechar): Change workarea and update ws::DisplayManager.
+  }
+}
+
 void PlatformScreenOzone::ProcessRemovedDisplays(
     const ui::DisplayConfigurator::DisplayStateList& snapshots) {
   std::vector<int64_t> current_ids;
   for (ui::DisplaySnapshot* snapshot : snapshots)
     current_ids.push_back(snapshot->display_id());
 
   // Find cached displays with no matching snapshot and mark as removed.
   for (DisplayInfo& display : cached_displays_) {
     if (std::find(current_ids.begin(), current_ids.end(), display.id) ==
         current_ids.end()) {
@@ skipping 128 matching lines @@
   LOG(ERROR) << "OnDisplayModeChangeFailed from DisplayConfigurator";
   wait_for_display_config_update_ = false;
 }
 
 void PlatformScreenOzone::Create(const shell::Identity& remote_identity,
                                  mojom::DisplayControllerRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace display