Add FakeDisplayDelegate for off device usage.

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 17 matching lines @@
 }  // namespace
 
 // static
 std::unique_ptr<PlatformScreen> PlatformScreen::Create() {
   return base::MakeUnique<PlatformScreenOzone>();
 }
 
 PlatformScreenOzone::PlatformScreenOzone() {}
 
 PlatformScreenOzone::~PlatformScreenOzone() {
+  // We are shutting down and don't want to make anymore display changes.
+  fake_display_controller_ = nullptr;
   display_configurator_.RemoveObserver(this);
 }
 
 void PlatformScreenOzone::AddInterfaces(shell::InterfaceRegistry* registry) {
   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();
+
+  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(
-      ui::OzonePlatform::GetInstance()->CreateNativeDisplayDelegate(), false);
-
-  if (base::SysInfo::IsRunningOnChromeOS()) {
-    display_configurator_.ForceInitialConfigure(kChromeOsBootColor);
-  } else {
-    if (base::CommandLine::ForCurrentProcess()->HasSwitch("multi-display")) {
-      // This really doesn't work properly. Use at your own risk.
-      display_configurator_.AddVirtualDisplay(gfx::Size(800, 800));
-      display_configurator_.AddVirtualDisplay(gfx::Size(800, 800));
-    } else {
-      display_configurator_.AddVirtualDisplay(gfx::Size(1024, 768));
-    }
-  }
+  display_configurator_.Init(std::move(native_display_delegate), false);
+  display_configurator_.ForceInitialConfigure(kChromeOsBootColor);
 }
 
 int64_t PlatformScreenOzone::GetPrimaryDisplayId() const {
   return primary_display_id_;
 }
 
 void PlatformScreenOzone::ToggleVirtualDisplay() {
-  if (base::SysInfo::IsRunningOnChromeOS())
+  if (!fake_display_controller_ || wait_for_display_config_update_)
     return;
 
-  // TODO(kylechar): Convert to use VirtualDisplayDelegate once landed.
   if (cached_displays_.size() == 1) {
-    display_configurator_.AddVirtualDisplay(cached_displays_[0].bounds.size());
+    const gfx::Size& display_size = cached_displays_[0].bounds.size();
+    wait_for_display_config_update_ =
+        fake_display_controller_->AddDisplay(display_size) !=
+        Display::kInvalidDisplayID;
   } else if (cached_displays_.size() > 1) {
-    display_configurator_.RemoveVirtualDisplay(cached_displays_.back().id);
+    wait_for_display_config_update_ =
+        fake_display_controller_->RemoveDisplay(cached_displays_.back().id);
   } else {
     NOTREACHED();
   }
 }
 
 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());
@@ skipping 94 matching lines @@
                         return display_info.id == display_id;
                       });
 }
 
 void PlatformScreenOzone::OnDisplayModeChanged(
     const ui::DisplayConfigurator::DisplayStateList& displays) {
   ProcessRemovedDisplays(displays);
   ProcessModifiedDisplays(displays);
   UpdateCachedDisplays();
   AddNewDisplays(displays);
+  wait_for_display_config_update_ = false;
 }
 
 void PlatformScreenOzone::OnDisplayModeChangeFailed(
     const ui::DisplayConfigurator::DisplayStateList& displays,
     ui::MultipleDisplayState failed_new_state) {
   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