Renames WmShell to ShellPort

ash/wm/maximize_mode/maximize_mode_controller.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/wm/maximize_mode/maximize_mode_controller.h"
 
 #include <utility>
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
+#include "ash/shell_port.h"
 #include "ash/wm/maximize_mode/maximize_mode_window_manager.h"
 #include "ash/wm/maximize_mode/scoped_disable_internal_mouse_and_keyboard.h"
-#include "ash/wm_shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/chromeos/accelerometer/accelerometer_util.h"
 #include "ui/display/display.h"
 #include "ui/events/event.h"
@@ skipping 81 matching lines @@
 
 MaximizeModeController::MaximizeModeController()
     : have_seen_accelerometer_data_(false),
       can_detect_lid_angle_(false),
       touchview_usage_interval_start_time_(base::Time::Now()),
       tick_clock_(new base::DefaultTickClock()),
       tablet_mode_switch_is_on_(false),
       lid_is_closed_(false),
       weak_factory_(this) {
   Shell::Get()->AddShellObserver(this);
-  WmShell::Get()->RecordUserMetricsAction(UMA_MAXIMIZE_MODE_INITIALLY_DISABLED);
+  ShellPort::Get()->RecordUserMetricsAction(
+      UMA_MAXIMIZE_MODE_INITIALLY_DISABLED);
 
   // TODO(jonross): Do not create MaximizeModeController if the flag is
   // unavailable. This will require refactoring
   // IsMaximizeModeWindowManagerEnabled to check for the existance of the
   // controller.
   if (IsEnabled()) {
-    WmShell::Get()->AddDisplayObserver(this);
+    ShellPort::Get()->AddDisplayObserver(this);
     chromeos::AccelerometerReader::GetInstance()->AddObserver(this);
   }
   chromeos::PowerManagerClient* power_manager_client =
       chromeos::DBusThreadManager::Get()->GetPowerManagerClient();
   power_manager_client->AddObserver(this);
   power_manager_client->GetSwitchStates(base::Bind(
       &MaximizeModeController::OnGetSwitchStates, weak_factory_.GetWeakPtr()));
 }
 
 MaximizeModeController::~MaximizeModeController() {
   Shell::Get()->RemoveShellObserver(this);
 
   if (IsEnabled()) {
-    WmShell::Get()->RemoveDisplayObserver(this);
+    ShellPort::Get()->RemoveDisplayObserver(this);
     chromeos::AccelerometerReader::GetInstance()->RemoveObserver(this);
   }
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(
       this);
 }
 
 bool MaximizeModeController::CanEnterMaximizeMode() {
   // If we have ever seen accelerometer data, then HandleHingeRotation may
   // trigger maximize mode at some point in the future.
   // All TouchView-enabled devices can enter maximized mode.
   return have_seen_accelerometer_data_ || IsEnabled();
 }
 
 // TODO(jcliang): Hide or remove EnableMaximizeModeWindowManager
 // (http://crbug.com/620241).
 void MaximizeModeController::EnableMaximizeModeWindowManager(
     bool should_enable) {
   bool is_enabled = !!maximize_mode_window_manager_.get();
   if (should_enable == is_enabled)
     return;
 
-  WmShell* shell = WmShell::Get();
-
   if (should_enable) {
     maximize_mode_window_manager_.reset(new MaximizeModeWindowManager());
     // TODO(jonross): Move the maximize mode notifications from ShellObserver
     // to MaximizeModeController::Observer
-    shell->RecordUserMetricsAction(UMA_MAXIMIZE_MODE_ENABLED);
+    ShellPort::Get()->RecordUserMetricsAction(UMA_MAXIMIZE_MODE_ENABLED);
     Shell::Get()->NotifyMaximizeModeStarted();
 
     observers_.ForAllPtrs([](mojom::TouchViewObserver* observer) {
       observer->OnTouchViewToggled(true);
     });
 
   } else {
     Shell::Get()->NotifyMaximizeModeEnding();
     maximize_mode_window_manager_.reset();
-    shell->RecordUserMetricsAction(UMA_MAXIMIZE_MODE_DISABLED);
+    ShellPort::Get()->RecordUserMetricsAction(UMA_MAXIMIZE_MODE_DISABLED);
     Shell::Get()->NotifyMaximizeModeEnded();
 
     observers_.ForAllPtrs([](mojom::TouchViewObserver* observer) {
       observer->OnTouchViewToggled(false);
     });
   }
 }
 
 bool MaximizeModeController::IsMaximizeModeWindowManagerEnabled() const {
   return maximize_mode_window_manager_.get() != NULL;
@@ skipping 18 matching lines @@
   can_detect_lid_angle_ =
       update->has(chromeos::ACCELEROMETER_SOURCE_SCREEN) &&
       update->has(chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD);
 
   if (!can_detect_lid_angle_)
     return;
 
   if (!display::Display::HasInternalDisplay())
     return;
 
-  if (!WmShell::Get()->IsActiveDisplayId(
+  if (!ShellPort::Get()->IsActiveDisplayId(
           display::Display::InternalDisplayId())) {
     return;
   }
 
   // Whether or not we enter maximize mode affects whether we handle screen
   // rotation, so determine whether to enter maximize mode first.
   if (ui::IsAccelerometerReadingStable(*update,
                                        chromeos::ACCELEROMETER_SOURCE_SCREEN) &&
       ui::IsAccelerometerReadingStable(
           *update, chromeos::ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD) &&
@@ skipping 22 matching lines @@
 void MaximizeModeController::TabletModeEventReceived(
     chromeos::PowerManagerClient::TabletMode mode,
     const base::TimeTicks& time) {
   if (!AllowEnterExitMaximizeMode())
     return;
 
   const bool on = mode == chromeos::PowerManagerClient::TabletMode::ON;
   tablet_mode_switch_is_on_ = on;
   // Do not change if docked.
   if (!display::Display::HasInternalDisplay() ||
-      !WmShell::Get()->IsActiveDisplayId(
+      !ShellPort::Get()->IsActiveDisplayId(
           display::Display::InternalDisplayId())) {
     return;
   }
   // The tablet mode switch activates at 300 degrees, so it is always reliable
   // when |on|. However we wish to exit maximize mode at a smaller angle, so
   // when |on| is false we ignore if it is possible to calculate the lid angle.
   if (on && !IsMaximizeModeWindowManagerEnabled()) {
     EnterMaximizeMode();
   } else if (!on && IsMaximizeModeWindowManagerEnabled() &&
              !can_detect_lid_angle_) {
@@ skipping 78 matching lines @@
              lid_angle >= kEnterMaximizeModeAngle &&
              (is_angle_stable || !WasLidOpenedRecently())) {
     EnterMaximizeMode();
   }
 }
 
 void MaximizeModeController::EnterMaximizeMode() {
   // Always reset first to avoid creation before destruction of a previous
   // object.
   event_blocker_ =
-      WmShell::Get()->CreateScopedDisableInternalMouseAndKeyboard();
+      ShellPort::Get()->CreateScopedDisableInternalMouseAndKeyboard();
 
   if (IsMaximizeModeWindowManagerEnabled())
     return;
   EnableMaximizeModeWindowManager(true);
 }
 
 void MaximizeModeController::LeaveMaximizeMode() {
   event_blocker_.reset();
 
   if (!IsMaximizeModeWindowManagerEnabled())
@@ skipping 13 matching lines @@
 }
 
 void MaximizeModeController::OnShellInitialized() {
   force_tablet_mode_ = GetMaximizeMode();
   if (force_tablet_mode_ == ForceTabletMode::TOUCHVIEW)
     EnterMaximizeMode();
 }
 
 void MaximizeModeController::OnDisplayConfigurationChanged() {
   if (!display::Display::HasInternalDisplay() ||
-      !WmShell::Get()->IsActiveDisplayId(
+      !ShellPort::Get()->IsActiveDisplayId(
           display::Display::InternalDisplayId())) {
     LeaveMaximizeMode();
   } else if (tablet_mode_switch_is_on_ &&
              !IsMaximizeModeWindowManagerEnabled()) {
     // The internal display has returned, as we are exiting docked mode.
     // The device is still in tablet mode, so trigger maximize mode, as this
     // switch leads to the ignoring of accelerometer events. When the switch is
     // not set the next stable accelerometer readings will trigger maximize
     // mode.
     EnterMaximizeMode();
@@ skipping 76 matching lines @@
   return elapsed_time.InSeconds() <= kLidRecentlyOpenedDurationSeconds;
 }
 
 void MaximizeModeController::SetTickClockForTest(
     std::unique_ptr<base::TickClock> tick_clock) {
   DCHECK(tick_clock_);
   tick_clock_ = std::move(tick_clock);
 }
 
 }  // namespace ash