Connect mojom::DisplayController from ash to ui.

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"
 #include "base/memory/ptr_util.h"
 #include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "services/shell/public/cpp/interface_registry.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/ozone/public/ozone_platform.h"
 
 namespace display {
 namespace {
 
 // Needed for DisplayConfigurator::ForceInitialConfigure.
 const SkColor kChromeOsBootColor = SkColorSetRGB(0xfe, 0xfe, 0xfe);
 
 }  // namespace
 
 // static
 std::unique_ptr<PlatformScreen> PlatformScreen::Create() {
   return base::MakeUnique<PlatformScreenOzone>();
 }
 
 PlatformScreenOzone::PlatformScreenOzone() {}
 
 PlatformScreenOzone::~PlatformScreenOzone() {
   display_configurator_.RemoveObserver(this);
 }
 
+void PlatformScreenOzone::AddInterfaces(shell::InterfaceRegistry* registry) {
+  registry->AddInterface<mojom::DisplayController>(this);

[dcheng, 2016/09/12 18:04:30]

Does this have other InterfaceFactory superclasses? Otherwise, I think you can
omit the template parameter here.

[kylechar, 2016/09/12 18:28:15]

No other interface factory superclasses, so yep it can be omitted. It's easier
to change and shorter but you lose the ability to grep for where the interface
is being added to the registry. What do you think is better style wise sky@?

[dcheng, 2016/09/13 01:04:48]

Ha, I forgot I was in favor of requiring this template argument explicitly
awhile back by removing the type deduction from the templated helper. That's
probably the way we should go (that way, at least it's searachable, as you said)
unless there's good reason to do otherwise.

[sky, 2016/09/13 02:07:40]

AddInterface<ExplicitTemplateArg> is mildly less confusing as you don't have to
look to the header to figure out what ExplicitTemplateArg is. Of course auto
goes against that. So, I don't feel strongly either way.

+}
+
 void PlatformScreenOzone::Init(PlatformScreenDelegate* delegate) {
   DCHECK(delegate);
   delegate_ = delegate;
 
   // 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));
     }
   }
 }
 
 int64_t PlatformScreenOzone::GetPrimaryDisplayId() const {
   return primary_display_id_;
 }
 
-void PlatformScreenOzone::ToggleVirtualDisplay(
-    const ToggleVirtualDisplayCallback& callback) {
-  if (base::SysInfo::IsRunningOnChromeOS()) {
-    callback.Run(false);
+void PlatformScreenOzone::ToggleVirtualDisplay() {
+  if (base::SysInfo::IsRunningOnChromeOS())
     return;
-  }
 
+  // TODO(kylechar): Convert to use VirtualDisplayDelegate once landed.
   if (cached_displays_.size() == 1) {
     display_configurator_.AddVirtualDisplay(cached_displays_[0].bounds.size());
-    callback.Run(true);
   } else if (cached_displays_.size() > 1) {
-    callback.Run(
-        display_configurator_.RemoveVirtualDisplay(cached_displays_.back().id));
+    display_configurator_.RemoveVirtualDisplay(cached_displays_.back().id);
   } else {
     NOTREACHED();
-    callback.Run(false);
   }
 }
 
 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.
@@ skipping 100 matching lines @@
   UpdateCachedDisplays();
   AddNewDisplays(displays);
 }
 
 void PlatformScreenOzone::OnDisplayModeChangeFailed(
     const ui::DisplayConfigurator::DisplayStateList& displays,
     ui::MultipleDisplayState failed_new_state) {
   LOG(ERROR) << "OnDisplayModeChangeFailed from DisplayConfigurator";
 }
 
+void PlatformScreenOzone::Create(const shell::Identity& remote_identity,
+                                 mojom::DisplayControllerRequest request) {
+  bindings_.AddBinding(this, std::move(request));
+}
+
 }  // namespace display