Merge display service providers and move to ash

ConsoleServiceProvider and DisplayPowerServiceProvider both now
implement org.chromium.DisplayService so merge them and their
delegate implementations and move them to src/ash since the
implementaitons only have ash dependencies.

The new implementation is owned by the recently introduced
AshDBusServices class.

BUG=798569

Change-Id: I54d3b332a68ba453613745ed8ead966efb925de9
Reviewed-on: https://chromium-review.googlesource.com/1041283
Commit-Queue: Steven Bennetts <stevenjb@chromium.org>
Reviewed-by: Dan Erat <derat@chromium.org>
Cr-Commit-Position: refs/heads/master@{#556003}

ash/BUILD.gn

@@ -118,6 +118,8 @@ component("ash") {
     "cast_config_controller.h",
     "dbus/ash_dbus_services.cc",
     "dbus/ash_dbus_services.h",
+    "dbus/display_service_provider.cc",
+    "dbus/display_service_provider.h",
     "dbus/url_handler_service_provider.cc",
     "dbus/url_handler_service_provider.h",
     "debug.cc",

ash/dbus/ash_dbus_services.cc

@@ -4,6 +4,7 @@
 
 #include "ash/dbus/ash_dbus_services.h"
 
+#include "ash/dbus/display_service_provider.h"
 #include "ash/dbus/url_handler_service_provider.h"
 #include "ash/public/cpp/config.h"
 #include "ash/shell.h"
@@ -30,6 +31,12 @@ AshDBusServices::AshDBusServices() {
       dbus::ObjectPath(chromeos::kUrlHandlerServicePath),
       chromeos::CrosDBusService::CreateServiceProviderList(
           std::make_unique<UrlHandlerServiceProvider>()));
+
+  display_service_ = chromeos::CrosDBusService::Create(
+      chromeos::kDisplayServiceName,
+      dbus::ObjectPath(chromeos::kDisplayServicePath),
+      chromeos::CrosDBusService::CreateServiceProviderList(
+          std::make_unique<DisplayServiceProvider>()));
 }
 
 void AshDBusServices::EmitAshInitialized() {
@@ -39,6 +46,7 @@ void AshDBusServices::EmitAshInitialized() {
 }
 
 AshDBusServices::~AshDBusServices() {
+  display_service_.reset();
   url_handler_service_.reset();
   if (initialized_dbus_thread_) {
     chromeos::DBusThreadManager::Shutdown();

ash/dbus/ash_dbus_services.h

@@ -29,6 +29,7 @@ class AshDBusServices {
  private:
   bool initialized_dbus_thread_{false};
   std::unique_ptr<chromeos::CrosDBusService> url_handler_service_;
+  std::unique_ptr<chromeos::CrosDBusService> display_service_;
 
   DISALLOW_COPY_AND_ASSIGN(AshDBusServices);
 };

ash/dbus/display_service_provider.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 "ash/dbus/display_service_provider.h"
+
+#include <utility>
+
+#include "ash/public/interfaces/ash_display_controller.mojom.h"
+#include "ash/public/interfaces/constants.mojom.h"
+#include "ash/shell.h"
+#include "ash/shell_delegate.h"
+#include "ash/wm/screen_dimmer.h"
+#include "base/bind.h"
+#include "base/callback.h"
+#include "dbus/message.h"
+#include "services/service_manager/public/cpp/connector.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+#include "ui/base/user_activity/user_activity_detector.h"
+#include "ui/display/manager/display_configurator.h"
+
+namespace ash {
+namespace {
+
+void OnDisplayOwnershipChanged(
+    const dbus::ExportedObject::ResponseSender& response_sender,
+    std::unique_ptr<dbus::Response> response,
+    bool status) {
+  dbus::MessageWriter writer(response.get());
+  writer.AppendBool(status);
+  response_sender.Run(std::move(response));
+}
+
+}  // namespace
+
+class DisplayServiceProvider::Impl {
+ public:
+  Impl() = default;
+  ~Impl() = default;
+
+  void SetDimming(bool dimmed);
+  void TakeDisplayOwnership(base::OnceCallback<void(bool)> callback);
+  void ReleaseDisplayOwnership(base::OnceCallback<void(bool)> callback);
+
+ private:
+  // Tests may not have a service_manager::Connector. Connect() is called
+  // whenever ash_display_controller_ is used to lazily connect as needed.
+  bool Connect();
+
+  mojom::AshDisplayControllerPtr ash_display_controller_;
+  std::unique_ptr<ScreenDimmer> screen_dimmer_;
+
+  DISALLOW_COPY_AND_ASSIGN(Impl);
+};
+
+bool DisplayServiceProvider::Impl::Connect() {
+  if (ash_display_controller_)
+    return true;
+  Shell::Get()->shell_delegate()->GetShellConnector()->BindInterface(
+      mojom::kServiceName, &ash_display_controller_);
+  return !!ash_display_controller_;
+}
+
+void DisplayServiceProvider::Impl::SetDimming(bool dimmed) {
+  if (!screen_dimmer_) {
+    screen_dimmer_ =
+        std::make_unique<ScreenDimmer>(ScreenDimmer::Container::ROOT);
+  }
+  screen_dimmer_->SetDimming(dimmed);
+}
+
+void DisplayServiceProvider::Impl::TakeDisplayOwnership(
+    base::OnceCallback<void(bool)> callback) {
+  if (!Connect()) {
+    LOG(ERROR) << "Display Controller not connected";
+    std::move(callback).Run(false);
+    return;
+  }
+  ash_display_controller_->TakeDisplayControl(std::move(callback));
+}
+
+void DisplayServiceProvider::Impl::ReleaseDisplayOwnership(
+    base::OnceCallback<void(bool)> callback) {
+  if (!Connect()) {
+    LOG(ERROR) << "Display Controller not connected";
+    std::move(callback).Run(false);
+    return;
+  }
+  ash_display_controller_->RelinquishDisplayControl(std::move(callback));
+}
+
+DisplayServiceProvider::DisplayServiceProvider()
+    : impl_(std::make_unique<Impl>()), weak_ptr_factory_(this) {}
+
+DisplayServiceProvider::~DisplayServiceProvider() = default;
+
+void DisplayServiceProvider::Start(
+    scoped_refptr<dbus::ExportedObject> exported_object) {
+  exported_object->ExportMethod(
+      chromeos::kDisplayServiceInterface,
+      chromeos::kDisplayServiceSetPowerMethod,
+      base::BindRepeating(&DisplayServiceProvider::SetDisplayPower,
+                          weak_ptr_factory_.GetWeakPtr()),
+      base::BindRepeating(&DisplayServiceProvider::OnExported,
+                          weak_ptr_factory_.GetWeakPtr()));
+
+  exported_object->ExportMethod(
+      chromeos::kDisplayServiceInterface,
+      chromeos::kDisplayServiceSetSoftwareDimmingMethod,
+      base::BindRepeating(&DisplayServiceProvider::SetDisplaySoftwareDimming,
+                          weak_ptr_factory_.GetWeakPtr()),
+      base::BindRepeating(&DisplayServiceProvider::OnExported,
+                          weak_ptr_factory_.GetWeakPtr()));
+
+  exported_object->ExportMethod(
+      chromeos::kDisplayServiceInterface,
+      chromeos::kDisplayServiceTakeOwnershipMethod,
+      base::BindRepeating(&DisplayServiceProvider::TakeDisplayOwnership,
+                          weak_ptr_factory_.GetWeakPtr()),
+      base::BindRepeating(&DisplayServiceProvider::OnExported,
+                          weak_ptr_factory_.GetWeakPtr()));
+
+  exported_object->ExportMethod(
+      chromeos::kDisplayServiceInterface,
+      chromeos::kDisplayServiceReleaseOwnershipMethod,
+      base::BindRepeating(&DisplayServiceProvider::ReleaseDisplayOwnership,
+                          weak_ptr_factory_.GetWeakPtr()),
+      base::BindRepeating(&DisplayServiceProvider::OnExported,
+                          weak_ptr_factory_.GetWeakPtr()));
+}
+
+void DisplayServiceProvider::SetDisplayPower(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  dbus::MessageReader reader(method_call);
+  int int_state = 0;
+  if (!reader.PopInt32(&int_state)) {
+    LOG(ERROR) << "Unable to parse request: "
+               << chromeos::kDisplayServiceSetPowerMethod;
+    response_sender.Run(dbus::Response::FromMethodCall(method_call));
+    return;
+  }
+
+  // Turning displays off when the device becomes idle or on just before
+  // we suspend may trigger a mouse move, which would then be incorrectly
+  // reported as user activity.  Let the UserActivityDetector
+  // know so that it can ignore such events.
+  ui::UserActivityDetector::Get()->OnDisplayPowerChanging();
+
+  Shell::Get()->display_configurator()->SetDisplayPower(
+      static_cast<chromeos::DisplayPowerState>(int_state),
+      display::DisplayConfigurator::kSetDisplayPowerNoFlags,
+      base::BindRepeating(
+          [](dbus::MethodCall* method_call,
+             dbus::ExportedObject::ResponseSender response_sender,
+             bool /*status*/) {
+            response_sender.Run(dbus::Response::FromMethodCall(method_call));
+          },
+          method_call, response_sender));
+}
+
+void DisplayServiceProvider::SetDisplaySoftwareDimming(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  dbus::MessageReader reader(method_call);
+  bool dimmed = false;
+  if (reader.PopBool(&dimmed)) {
+    impl_->SetDimming(dimmed);
+  } else {
+    LOG(ERROR) << "Unable to parse request: "
+               << chromeos::kDisplayServiceSetSoftwareDimmingMethod;
+  }
+  response_sender.Run(dbus::Response::FromMethodCall(method_call));
+}
+
+void DisplayServiceProvider::TakeDisplayOwnership(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  impl_->TakeDisplayOwnership(base::BindOnce(
+      &OnDisplayOwnershipChanged, response_sender,
+      base::Passed(dbus::Response::FromMethodCall(method_call))));
+}
+
+void DisplayServiceProvider::ReleaseDisplayOwnership(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  impl_->ReleaseDisplayOwnership(base::BindOnce(
+      &OnDisplayOwnershipChanged, response_sender,
+      base::Passed(dbus::Response::FromMethodCall(method_call))));
+}
+
+void DisplayServiceProvider::OnExported(const std::string& interface_name,
+                                        const std::string& method_name,
+                                        bool success) {
+  if (!success)
+    LOG(ERROR) << "Failed to export " << interface_name << "." << method_name;
+}
+
+}  // namespace ash

chromeos/dbus/services/console_service_provider.h → ash/dbus/display_service_provider.h

@@ -2,75 +2,64 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROMEOS_DBUS_SERVICES_CONSOLE_SERVICE_PROVIDER_H_
-#define CHROMEOS_DBUS_SERVICES_CONSOLE_SERVICE_PROVIDER_H_
+#ifndef ASH_DBUS_DISPLAY_SERVICE_PROVIDER_H_
+#define ASH_DBUS_DISPLAY_SERVICE_PROVIDER_H_
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "chromeos/chromeos_export.h"
 #include "chromeos/dbus/services/cros_dbus_service.h"
 #include "dbus/exported_object.h"
 
-namespace chromeos {
+namespace ash {
 
-// This class provides an API for external apps to notify
-// chrome that it should release control of the display server.
-// The main client is the console application.  This can
-// also be used by crouton to take over the display.
-class CHROMEOS_EXPORT ConsoleServiceProvider
-    : public CrosDBusService::ServiceProviderInterface {
+// This class implements org.chromium.DisplayService for chrome.
+class DisplayServiceProvider
+    : public chromeos::CrosDBusService::ServiceProviderInterface {
  public:
-  class Delegate {
-   public:
-    typedef base::Callback<void(bool)> UpdateOwnershipCallback;
-
-    virtual ~Delegate() {}
-
-    // Performs the actual work needed by the provider methods with the same
-    // names.
-    virtual void TakeDisplayOwnership(
-        const UpdateOwnershipCallback& callback) = 0;
-    virtual void ReleaseDisplayOwnership(
-        const UpdateOwnershipCallback& callback) = 0;
-  };
-
   // The caller must ensure that |delegate| outlives this object.
-  explicit ConsoleServiceProvider(Delegate* delegate);
-  ~ConsoleServiceProvider() override;
+  DisplayServiceProvider();
+  ~DisplayServiceProvider() override;
 
   // CrosDBusService::ServiceProviderInterface overrides:
   void Start(scoped_refptr<dbus::ExportedObject> exported_object) override;
 
  private:
-  // This method will get called when a external process no longer needs
-  // control of the display and Chrome can take ownership.
+  class Impl;
+
+  // Forwards DBus calls to DisplayConfigurator::SetDisplayPower.
+  void SetDisplayPower(dbus::MethodCall* method_call,
+                       dbus::ExportedObject::ResponseSender response_sender);
+
+  // Forwards DBus calls to ScreenDimmer::SetDimming.
+  void SetDisplaySoftwareDimming(
+      dbus::MethodCall* method_call,
+      dbus::ExportedObject::ResponseSender response_sender);
+
+  // Called when a external process no longer needs control of the display and
+  // Chrome can take ownership. Forwarded to mojom::AshDisplayController.
   void TakeDisplayOwnership(
       dbus::MethodCall* method_call,
       dbus::ExportedObject::ResponseSender response_sender);
 
-  // This method will get called when a external process needs control of
-  // the display and needs Chrome to release ownership.
+  // Called when a external process needs control of the display and needs
+  // Chrome to release ownership. Forwarded to mojom::AshDisplayController.
   void ReleaseDisplayOwnership(
       dbus::MethodCall* method_call,
       dbus::ExportedObject::ResponseSender response_sender);
 
-  // This method is called when a dbus method is exported.  If the export of the
-  // method is successful, |success| will be true.  It will be false
-  // otherwise.
   void OnExported(const std::string& interface_name,
                   const std::string& method_name,
                   bool success);
 
-  Delegate* delegate_;  // Not owned.
-
-  base::WeakPtrFactory<ConsoleServiceProvider> weak_ptr_factory_;
+  std::unique_ptr<Impl> impl_;
+  base::WeakPtrFactory<DisplayServiceProvider> weak_ptr_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(ConsoleServiceProvider);
+  DISALLOW_COPY_AND_ASSIGN(DisplayServiceProvider);
 };
 
-}  // namespace chromeos
+}  // namespace ash
 
-#endif  // CHROMEOS_DBUS_SERVICES_CONSOLE_SERVICE_PROVIDER_H_
+#endif  // ASH_DBUS_DISPLAY_SERVICE_PROVIDER_H_

chrome/browser/chromeos/BUILD.gn

@@ -523,10 +523,6 @@ source_set("chromeos") {
     "customization/customization_wallpaper_downloader.h",
     "customization/customization_wallpaper_util.cc",
     "customization/customization_wallpaper_util.h",
-    "dbus/chrome_console_service_provider_delegate.cc",
-    "dbus/chrome_console_service_provider_delegate.h",
-    "dbus/chrome_display_power_service_provider_delegate.cc",
-    "dbus/chrome_display_power_service_provider_delegate.h",
     "dbus/chrome_proxy_resolution_service_provider_delegate.cc",
     "dbus/chrome_proxy_resolution_service_provider_delegate.h",
     "dbus/chrome_virtual_file_request_service_provider_delegate.cc",

chrome/browser/chromeos/chrome_browser_main_chromeos.cc

@@ -46,8 +46,6 @@
 #include "chrome/browser/chromeos/arc/voice_interaction/voice_interaction_controller_client.h"
 #include "chrome/browser/chromeos/ash_config.h"
 #include "chrome/browser/chromeos/boot_times_recorder.h"
-#include "chrome/browser/chromeos/dbus/chrome_console_service_provider_delegate.h"
-#include "chrome/browser/chromeos/dbus/chrome_display_power_service_provider_delegate.h"
 #include "chrome/browser/chromeos/dbus/chrome_proxy_resolution_service_provider_delegate.h"
 #include "chrome/browser/chromeos/dbus/chrome_virtual_file_request_service_provider_delegate.h"
 #include "chrome/browser/chromeos/dbus/component_updater_service_provider.h"
@@ -125,9 +123,7 @@
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_policy_controller.h"
 #include "chromeos/dbus/services/chrome_features_service_provider.h"
-#include "chromeos/dbus/services/console_service_provider.h"
 #include "chromeos/dbus/services/cros_dbus_service.h"
-#include "chromeos/dbus/services/display_power_service_provider.h"
 #include "chromeos/dbus/services/liveness_service_provider.h"
 #include "chromeos/dbus/services/proxy_resolution_service_provider.h"
 #include "chromeos/dbus/services/virtual_file_request_service_provider.h"
@@ -332,14 +328,7 @@ class DBusServices {
     }
 
     CrosDBusService::ServiceProviderList service_providers;
-    CrosDBusService::ServiceProviderList display_service_providers;
 
-    if (GetAshConfig() != ash::Config::MASH) {
-      // TODO(lannm): This will eventually be served by mus-ws.
-      display_service_providers.push_back(
-          std::make_unique<DisplayPowerServiceProvider>(
-              std::make_unique<ChromeDisplayPowerServiceProviderDelegate>()));
-    }
     // TODO(derat): Remove this provider once all callers are using
     // |liveness_service_| instead: https://crbug.com/644322
     service_providers.push_back(
@@ -349,10 +338,6 @@ class DBusServices {
     service_providers.push_back(std::make_unique<ScreenLockServiceProvider>(
         kLibCrosServiceInterface, kLockScreen));
 
-    display_service_providers.push_back(
-        std::make_unique<ConsoleServiceProvider>(
-            &console_service_provider_delegate_));
-
     // TODO(derat): Remove this provider once all callers are using
     // |kiosk_info_service_| instead: https://crbug.com/703229
     service_providers.push_back(std::make_unique<KioskInfoService>(
@@ -361,10 +346,6 @@ class DBusServices {
         kLibCrosServiceName, dbus::ObjectPath(kLibCrosServicePath),
         std::move(service_providers));
 
-    display_service_ = CrosDBusService::Create(
-        kDisplayServiceName, dbus::ObjectPath(kDisplayServicePath),
-        std::move(display_service_providers));
-
     proxy_resolution_service_ = CrosDBusService::Create(
         kNetworkProxyServiceName, dbus::ObjectPath(kNetworkProxyServicePath),
         CrosDBusService::CreateServiceProviderList(
@@ -458,7 +439,6 @@ class DBusServices {
     CertLoader::Shutdown();
     TPMTokenLoader::Shutdown();
     cros_dbus_service_.reset();
-    display_service_.reset();
     proxy_resolution_service_.reset();
     kiosk_info_service_.reset();
     liveness_service_.reset();
@@ -473,11 +453,6 @@ class DBusServices {
     bluez::BluezDBusManager::Shutdown();
   }
 
-  void ServiceManagerConnectionStarted(
-      content::ServiceManagerConnection* connection) {
-    console_service_provider_delegate_.Connect(connection->GetConnector());
-  }
-
  private:
   // Hosts providers for the "org.chromium.LibCrosService" D-Bus service owned
   // by Chrome. The name of this service was chosen for historical reasons that
@@ -486,7 +461,6 @@ class DBusServices {
   // split between different processes: http://crbug.com/692246
   std::unique_ptr<CrosDBusService> cros_dbus_service_;
 
-  std::unique_ptr<CrosDBusService> display_service_;
   std::unique_ptr<CrosDBusService> proxy_resolution_service_;
   std::unique_ptr<CrosDBusService> kiosk_info_service_;
   std::unique_ptr<CrosDBusService> liveness_service_;
@@ -496,8 +470,6 @@ class DBusServices {
   std::unique_ptr<CrosDBusService> finch_features_service_;
   std::unique_ptr<CrosDBusService> vm_applications_service_;
 
-  ChromeConsoleServiceProviderDelegate console_service_provider_delegate_;
-
   DISALLOW_COPY_AND_ASSIGN(DBusServices);
 };
 
@@ -682,12 +654,6 @@ void ChromeBrowserMainPartsChromeos::PostMainMessageLoopStart() {
   ChromeBrowserMainPartsLinux::PostMainMessageLoopStart();
 }
 
-void ChromeBrowserMainPartsChromeos::ServiceManagerConnectionStarted(
-    content::ServiceManagerConnection* connection) {
-  ChromeBrowserMainPartsLinux::ServiceManagerConnectionStarted(connection);
-  dbus_services_->ServiceManagerConnectionStarted(connection);
-}
-
 // Threads are initialized between MainMessageLoopStart and MainMessageLoopRun.
 // about_flags settings are applied in ChromeBrowserMainParts::PreCreateThreads.
 void ChromeBrowserMainPartsChromeos::PreMainMessageLoopRun() {

chrome/browser/chromeos/chrome_browser_main_chromeos.h

@@ -78,8 +78,6 @@ class ChromeBrowserMainPartsChromeos : public ChromeBrowserMainPartsLinux {
   int PreEarlyInitialization() override;
   void PreMainMessageLoopStart() override;
   void PostMainMessageLoopStart() override;
-  void ServiceManagerConnectionStarted(
-      content::ServiceManagerConnection* connection) override;
   void PreMainMessageLoopRun() override;
 
   // Stages called from PreMainMessageLoopRun.

chrome/browser/chromeos/dbus/chrome_console_service_provider_delegate.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 "chrome/browser/chromeos/dbus/chrome_console_service_provider_delegate.h"
-
-#include "ash/public/interfaces/constants.mojom.h"
-#include "services/service_manager/public/cpp/connector.h"
-#include "ui/display/manager/display_configurator.h"
-
-namespace chromeos {
-
-ChromeConsoleServiceProviderDelegate::ChromeConsoleServiceProviderDelegate() {}
-
-ChromeConsoleServiceProviderDelegate::~ChromeConsoleServiceProviderDelegate() {}
-
-void ChromeConsoleServiceProviderDelegate::Connect(
-    service_manager::Connector* connector) {
-  connector->BindInterface(ash::mojom::kServiceName, &ash_display_controller_);
-}
-
-void ChromeConsoleServiceProviderDelegate::TakeDisplayOwnership(
-    const UpdateOwnershipCallback& callback) {
-  if (!ash_display_controller_) {
-    callback.Run(false);
-    return;
-  }
-  ash_display_controller_->TakeDisplayControl(callback);
-}
-
-void ChromeConsoleServiceProviderDelegate::ReleaseDisplayOwnership(
-    const UpdateOwnershipCallback& callback) {
-  if (!ash_display_controller_) {
-    callback.Run(false);
-    return;
-  }
-  ash_display_controller_->RelinquishDisplayControl(callback);
-}
-
-}  // namespace chromeos

chrome/browser/chromeos/dbus/chrome_console_service_provider_delegate.h

-// 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.
-
-#ifndef CHROME_BROWSER_CHROMEOS_DBUS_CHROME_CONSOLE_SERVICE_PROVIDER_DELEGATE_H_
-#define CHROME_BROWSER_CHROMEOS_DBUS_CHROME_CONSOLE_SERVICE_PROVIDER_DELEGATE_H_
-
-#include "ash/public/interfaces/ash_display_controller.mojom.h"
-#include "base/macros.h"
-#include "chromeos/dbus/services/console_service_provider.h"
-
-namespace service_manager {
-class Connector;
-}
-
-namespace chromeos {
-
-// Chrome's implementation of ConsoleServiceProvider::Delegate
-class ChromeConsoleServiceProviderDelegate
-    : public ConsoleServiceProvider::Delegate {
- public:
-  ChromeConsoleServiceProviderDelegate();
-  ~ChromeConsoleServiceProviderDelegate() override;
-
-  void Connect(service_manager::Connector* connector);
-
-  // ConsoleServiceProvider::Delegate overrides:
-  void TakeDisplayOwnership(const UpdateOwnershipCallback& callback) override;
-  void ReleaseDisplayOwnership(
-      const UpdateOwnershipCallback& callback) override;
-
- private:
-  ash::mojom::AshDisplayControllerPtr ash_display_controller_;
-
-  DISALLOW_COPY_AND_ASSIGN(ChromeConsoleServiceProviderDelegate);
-};
-
-}  // namespace chromeos
-
-#endif  // CHROME_BROWSER_CHROMEOS_DBUS_CHROME_CONSOLE_SERVICE_PROVIDER_DELEGATE_H_

chrome/browser/chromeos/dbus/chrome_display_power_service_provider_delegate.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 "chrome/browser/chromeos/dbus/chrome_display_power_service_provider_delegate.h"
-
-#include "ash/shell.h"
-#include "ash/wm/screen_dimmer.h"
-#include "ui/base/user_activity/user_activity_detector.h"
-#include "ui/display/manager/display_configurator.h"
-
-namespace chromeos {
-
-ChromeDisplayPowerServiceProviderDelegate::
-ChromeDisplayPowerServiceProviderDelegate() {
-}
-
-ChromeDisplayPowerServiceProviderDelegate::
-~ChromeDisplayPowerServiceProviderDelegate() {
-}
-
-void ChromeDisplayPowerServiceProviderDelegate::SetDisplayPower(
-    DisplayPowerState power_state,
-    const ResponseCallback& callback) {
-  // Turning displays off when the device becomes idle or on just before
-  // we suspend may trigger a mouse move, which would then be incorrectly
-  // reported as user activity.  Let the UserActivityDetector
-  // know so that it can ignore such events.
-  ui::UserActivityDetector::Get()->OnDisplayPowerChanging();
-
-  ash::Shell::Get()->display_configurator()->SetDisplayPower(
-      power_state, display::DisplayConfigurator::kSetDisplayPowerNoFlags,
-      callback);
-}
-
-void ChromeDisplayPowerServiceProviderDelegate::SetDimming(bool dimmed) {
-  if (!screen_dimmer_) {
-    screen_dimmer_ =
-        std::make_unique<ash::ScreenDimmer>(ash::ScreenDimmer::Container::ROOT);
-  }
-  screen_dimmer_->SetDimming(dimmed);
-}
-
-}  // namespace chromeos

chrome/browser/chromeos/dbus/chrome_display_power_service_provider_delegate.h

-// 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.
-
-#ifndef CHROME_BROWSER_CHROMEOS_DBUS_CHROME_DISPLAY_POWER_SERVICE_PROVIDER_DELEGATE_H_
-#define CHROME_BROWSER_CHROMEOS_DBUS_CHROME_DISPLAY_POWER_SERVICE_PROVIDER_DELEGATE_H_
-
-#include <memory>
-
-#include "base/macros.h"
-#include "chromeos/dbus/services/display_power_service_provider.h"
-
-namespace ash {
-class ScreenDimmer;
-}
-
-namespace chromeos {
-
-// Chrome's implementation of DisplayPowerServiceProvider::Delegate
-class ChromeDisplayPowerServiceProviderDelegate
-    : public DisplayPowerServiceProvider::Delegate {
- public:
-  ChromeDisplayPowerServiceProviderDelegate();
-  ~ChromeDisplayPowerServiceProviderDelegate() override;
-
-  // DisplayPowerServiceProvider::Delegate overrides:
-  void SetDisplayPower(DisplayPowerState power_state,
-                       const ResponseCallback& callback) override;
-  void SetDimming(bool dimmed) override;
-
- private:
-  std::unique_ptr<ash::ScreenDimmer> screen_dimmer_;
-
-  DISALLOW_COPY_AND_ASSIGN(ChromeDisplayPowerServiceProviderDelegate);
-};
-
-}  // namespace chromeos
-
-#endif  // CHROME_BROWSER_CHROMEOS_DBUS_CHROME_DISPLAY_POWER_SERVICE_PROVIDER_DELEGATE_H_

chromeos/BUILD.gn

@@ -267,12 +267,8 @@ component("chromeos") {
     "dbus/power_policy_controller.h",
     "dbus/services/chrome_features_service_provider.cc",
     "dbus/services/chrome_features_service_provider.h",
-    "dbus/services/console_service_provider.cc",
-    "dbus/services/console_service_provider.h",
     "dbus/services/cros_dbus_service.cc",
     "dbus/services/cros_dbus_service.h",
-    "dbus/services/display_power_service_provider.cc",
-    "dbus/services/display_power_service_provider.h",
     "dbus/services/liveness_service_provider.cc",
     "dbus/services/liveness_service_provider.h",
     "dbus/services/proxy_resolution_service_provider.cc",

chromeos/dbus/services/console_service_provider.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 "chromeos/dbus/services/console_service_provider.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "dbus/message.h"
-#include "third_party/cros_system_api/dbus/service_constants.h"
-
-namespace chromeos {
-namespace {
-
-void OnDisplayOwnershipChanged(
-    const dbus::ExportedObject::ResponseSender& response_sender,
-    std::unique_ptr<dbus::Response> response,
-    bool status) {
-  dbus::MessageWriter writer(response.get());
-  writer.AppendBool(status);
-  response_sender.Run(std::move(response));
-}
-
-}  // namespace
-
-ConsoleServiceProvider::ConsoleServiceProvider(Delegate* delegate)
-    : delegate_(delegate), weak_ptr_factory_(this) {}
-
-ConsoleServiceProvider::~ConsoleServiceProvider() = default;
-
-void ConsoleServiceProvider::Start(
-    scoped_refptr<dbus::ExportedObject> exported_object) {
-  exported_object->ExportMethod(
-      kDisplayServiceInterface, kDisplayServiceTakeOwnershipMethod,
-      base::Bind(&ConsoleServiceProvider::TakeDisplayOwnership,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ConsoleServiceProvider::OnExported,
-                 weak_ptr_factory_.GetWeakPtr()));
-
-  exported_object->ExportMethod(
-      kDisplayServiceInterface, kDisplayServiceReleaseOwnershipMethod,
-      base::Bind(&ConsoleServiceProvider::ReleaseDisplayOwnership,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&ConsoleServiceProvider::OnExported,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void ConsoleServiceProvider::TakeDisplayOwnership(
-    dbus::MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
-  delegate_->TakeDisplayOwnership(
-      base::Bind(&OnDisplayOwnershipChanged, response_sender,
-                 base::Passed(dbus::Response::FromMethodCall(method_call))));
-}
-
-void ConsoleServiceProvider::ReleaseDisplayOwnership(
-    dbus::MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
-  delegate_->ReleaseDisplayOwnership(
-      base::Bind(&OnDisplayOwnershipChanged, response_sender,
-                 base::Passed(dbus::Response::FromMethodCall(method_call))));
-}
-
-void ConsoleServiceProvider::OnExported(const std::string& interface_name,
-                                        const std::string& method_name,
-                                        bool success) {
-  if (!success)
-    LOG(ERROR) << "failed to export " << interface_name << "." << method_name;
-}
-
-}  // namespace chromeos

chromeos/dbus/services/display_power_service_provider.cc

-// Copyright (c) 2013 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 "chromeos/dbus/services/display_power_service_provider.h"
-
-#include <utility>
-
-#include "base/bind.h"
-#include "dbus/message.h"
-
-namespace chromeos {
-
-namespace {
-
-void RunConfigurationCallback(
-    dbus::MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender,
-    bool status) {
-  response_sender.Run(dbus::Response::FromMethodCall(method_call));
-}
-
-}  // namespace
-
-DisplayPowerServiceProvider::DisplayPowerServiceProvider(
-    std::unique_ptr<Delegate> delegate)
-    : delegate_(std::move(delegate)), weak_ptr_factory_(this) {}
-
-DisplayPowerServiceProvider::~DisplayPowerServiceProvider() = default;
-
-void DisplayPowerServiceProvider::Start(
-    scoped_refptr<dbus::ExportedObject> exported_object) {
-  exported_object->ExportMethod(
-      kDisplayServiceInterface, kDisplayServiceSetPowerMethod,
-      base::Bind(&DisplayPowerServiceProvider::SetDisplayPower,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&DisplayPowerServiceProvider::OnExported,
-                 weak_ptr_factory_.GetWeakPtr()));
-  exported_object->ExportMethod(
-      kDisplayServiceInterface, kDisplayServiceSetSoftwareDimmingMethod,
-      base::Bind(&DisplayPowerServiceProvider::SetDisplaySoftwareDimming,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::Bind(&DisplayPowerServiceProvider::OnExported,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void DisplayPowerServiceProvider::OnExported(const std::string& interface_name,
-                                             const std::string& method_name,
-                                             bool success) {
-  if (!success) {
-    LOG(ERROR) << "Failed to export " << interface_name << "."
-               << method_name;
-  }
-}
-
-void DisplayPowerServiceProvider::SetDisplayPower(
-    dbus::MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
-  dbus::MessageReader reader(method_call);
-  int int_state = 0;
-  Delegate::ResponseCallback callback =
-      base::Bind(&RunConfigurationCallback, method_call, response_sender);
-  if (reader.PopInt32(&int_state)) {
-    DisplayPowerState state = static_cast<DisplayPowerState>(int_state);
-    delegate_->SetDisplayPower(state, callback);
-  } else {
-    LOG(ERROR) << "Unable to parse " << kDisplayServiceSetPowerMethod
-               << " request";
-    callback.Run(false);
-  }
-}
-
-void DisplayPowerServiceProvider::SetDisplaySoftwareDimming(
-    dbus::MethodCall* method_call,
-    dbus::ExportedObject::ResponseSender response_sender) {
-  dbus::MessageReader reader(method_call);
-  bool dimmed = false;
-  if (reader.PopBool(&dimmed)) {
-    delegate_->SetDimming(dimmed);
-  } else {
-    LOG(ERROR) << "Unable to parse " << kDisplayServiceSetSoftwareDimmingMethod
-               << " request";
-  }
-  response_sender.Run(dbus::Response::FromMethodCall(method_call));
-}
-
-}  // namespace chromeos

chromeos/dbus/services/display_power_service_provider.h

-// Copyright (c) 2013 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.
-
-#ifndef CHROMEOS_DBUS_SERVICES_DISPLAY_POWER_SERVICE_PROVIDER_H_
-#define CHROMEOS_DBUS_SERVICES_DISPLAY_POWER_SERVICE_PROVIDER_H_
-
-#include <memory>
-#include <string>
-
-#include "base/compiler_specific.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/weak_ptr.h"
-#include "chromeos/chromeos_export.h"
-#include "chromeos/dbus/services/cros_dbus_service.h"
-#include "dbus/exported_object.h"
-#include "third_party/cros_system_api/dbus/service_constants.h"
-
-namespace dbus {
-class MethodCall;
-}
-
-namespace chromeos {
-
-// This class exports "SetDisplayPower" and "SetDisplaySoftwareDimming"
-// D-Bus methods that the power manager calls to instruct Chrome to turn
-// various displays on or off or dim them.
-class CHROMEOS_EXPORT DisplayPowerServiceProvider
-    : public CrosDBusService::ServiceProviderInterface {
- public:
-  class Delegate {
-   public:
-    typedef base::Callback<void(bool)> ResponseCallback;
-
-    virtual ~Delegate() {}
-
-    // Sets the display power state. After the display power is set, |callback|
-    // is called with the operation status.
-    virtual void SetDisplayPower(DisplayPowerState power_state,
-                                 const ResponseCallback& callback) = 0;
-
-    // Dims or undims the screen.
-    virtual void SetDimming(bool dimmed) = 0;
-  };
-
-  explicit DisplayPowerServiceProvider(std::unique_ptr<Delegate> delegate);
-  ~DisplayPowerServiceProvider() override;
-
-  // CrosDBusService::ServiceProviderInterface overrides:
-  void Start(scoped_refptr<dbus::ExportedObject> exported_object) override;
-
- private:
-  // Called from ExportedObject when a handler is exported as a D-Bus
-  // method or failed to be exported.
-  void OnExported(const std::string& interface_name,
-                  const std::string& method_name,
-                  bool success);
-
-  // Called on UI thread in response to D-Bus requests.
-  void SetDisplayPower(dbus::MethodCall* method_call,
-                       dbus::ExportedObject::ResponseSender response_sender);
-  void SetDisplaySoftwareDimming(
-      dbus::MethodCall* method_call,
-      dbus::ExportedObject::ResponseSender response_sender);
-
-  std::unique_ptr<Delegate> delegate_;
-
-  // Keep this last so that all weak pointers will be invalidated at the
-  // beginning of destruction.
-  base::WeakPtrFactory<DisplayPowerServiceProvider> weak_ptr_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(DisplayPowerServiceProvider);
-};
-
-}  // namespace chromeos
-
-#endif  // CHROMEOS_DBUS_SERVICES_DISPLAY_POWER_SERVICE_PROVIDER_H_