mash: Allow a subset of D-Bus clients to be created in DBusThreadManager

ash/system/chromeos/power/power_event_observer.cc

 // Copyright 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 "ash/system/chromeos/power/power_event_observer.h"
 
+#include "ash/common/dbus_thread_manager_ash.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/system/tray/system_tray_notifier.h"
 #include "ash/common/wm_shell.h"
 #include "ash/shell.h"
 #include "ash/wm/power_button_controller.h"
-#include "chromeos/dbus/dbus_thread_manager.h"
+// #include "chromeos/dbus/dbus_thread_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/user_activity/user_activity_detector.h"
 #include "ui/compositor/compositor.h"
 #include "ui/display/chromeos/display_configurator.h"
 
 namespace ash {
 
 namespace {
 
@@ skipping 15 matching lines @@
 
 void OnSuspendDisplaysCompleted(const base::Closure& suspend_callback,
                                 bool status) {
   suspend_callback.Run();
 }
 
 }  // namespace
 
 PowerEventObserver::PowerEventObserver()
     : screen_locked_(false), waiting_for_lock_screen_animations_(false) {
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(
+  DBusThreadManagerAsh::Get()->GetPowerManagerClient()->AddObserver(
       this);
-  chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->AddObserver(
+  DBusThreadManagerAsh::Get()->GetSessionManagerClient()->AddObserver(
       this);
 }
 
 PowerEventObserver::~PowerEventObserver() {
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(
+  DBusThreadManagerAsh::Get()->GetPowerManagerClient()->RemoveObserver(
       this);
-  chromeos::DBusThreadManager::Get()->GetSessionManagerClient()->RemoveObserver(
+  DBusThreadManagerAsh::Get()->GetSessionManagerClient()->RemoveObserver(
       this);
 }
 
 void PowerEventObserver::OnLockAnimationsComplete() {
   VLOG(1) << "Screen locker animations have completed.";
   waiting_for_lock_screen_animations_ = false;
 
   if (!screen_lock_callback_.is_null()) {
     StopRenderingRequests();
 
@@ skipping 18 matching lines @@
   // until the lock screen is fully visible.  While it is sufficient from a
   // security perspective to block only until the lock screen is ready, which
   // guarantees that the contents of the user's screen are no longer visible,
   // this leads to poor UX on the first resume since neither the user pod nor
   // the header bar will be visible for a few hundred milliseconds until the GPU
   // process starts rendering again.  To deal with this, the suspend is delayed
   // until all the lock screen animations have completed and the suspend request
   // is unblocked from OnLockAnimationsComplete().
   if (!screen_locked_ && delegate->ShouldLockScreenBeforeSuspending() &&
       delegate->CanLockScreen()) {
-    screen_lock_callback_ = chromeos::DBusThreadManager::Get()
+    screen_lock_callback_ = DBusThreadManagerAsh::Get()
                                 ->GetPowerManagerClient()
                                 ->GetSuspendReadinessCallback();
     VLOG(1) << "Requesting screen lock from PowerEventObserver";
-    chromeos::DBusThreadManager::Get()
+    DBusThreadManagerAsh::Get()
         ->GetSessionManagerClient()
         ->RequestLockScreen();
   } else if (waiting_for_lock_screen_animations_) {
     // The lock-before-suspending pref has been set and the lock screen is ready
     // but the animations have not completed yet.  This can happen if a suspend
     // request is canceled after the lock screen is ready but before the
     // animations have completed and then another suspend request is immediately
     // started.  In practice, it is highly unlikely that this will ever happen
     // but it's better to be safe since the cost of not dealing with it properly
     // is a memory leak in the GPU and weird artifacts on the screen.
-    screen_lock_callback_ = chromeos::DBusThreadManager::Get()
+    screen_lock_callback_ = DBusThreadManagerAsh::Get()
                                 ->GetPowerManagerClient()
                                 ->GetSuspendReadinessCallback();
   } else {
     // The lock-before-suspending pref is not set or the screen has already been
     // locked and the animations have completed.  Rendering can be stopped now.
     StopRenderingRequests();
   }
 
   ui::UserActivityDetector::Get()->OnDisplayPowerChanging();
   Shell::GetInstance()->display_configurator()->SuspendDisplays(base::Bind(
-      &OnSuspendDisplaysCompleted, chromeos::DBusThreadManager::Get()
+      &OnSuspendDisplaysCompleted, DBusThreadManagerAsh::Get()
                                        ->GetPowerManagerClient()
                                        ->GetSuspendReadinessCallback()));
 }
 
 void PowerEventObserver::SuspendDone(const base::TimeDelta& sleep_duration) {
   Shell::GetInstance()->display_configurator()->ResumeDisplays();
   WmShell::Get()->system_tray_notifier()->NotifyRefreshClock();
 
   // If the suspend request was being blocked while waiting for the lock
   // animation to complete, clear the blocker since the suspend has already
@@ skipping 15 matching lines @@
   } else {
     VLOG(1) << "Screen locked without suspend";
   }
 }
 
 void PowerEventObserver::ScreenIsUnlocked() {
   screen_locked_ = false;
 }
 
 }  // namespace ash