Cleanup: Remove unnecessary ".get()" from scoped_ptrs<>.

ash/shell.cc

 // Copyright (c) 2012 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/shell.h"
 
 #include <algorithm>
 #include <string>
 
 #include "ash/accelerators/focus_manager_factory.h"
@@ skipping 227 matching lines @@
   // See bug crbug.com/134502.
   if (active_root_window_)
     aura::client::GetFocusClient(active_root_window_)->FocusWindow(NULL);
 
   // Please keep in same order as in Init() because it's easy to miss one.
   RemovePreTargetHandler(user_activity_detector_.get());
   RemovePreTargetHandler(event_rewriter_filter_.get());
   RemovePreTargetHandler(overlay_filter_.get());
   RemovePreTargetHandler(input_method_filter_.get());
   RemovePreTargetHandler(window_modality_controller_.get());
-  if (mouse_cursor_filter_.get())
+  if (mouse_cursor_filter_)
     RemovePreTargetHandler(mouse_cursor_filter_.get());
   RemovePreTargetHandler(system_gesture_filter_.get());
 #if !defined(OS_MACOSX)
   RemovePreTargetHandler(accelerator_filter_.get());
 #endif
 
   // TooltipController is deleted with the Shell so removing its references.
   RemovePreTargetHandler(tooltip_controller_.get());
 
   // AppList needs to be released before shelf layout manager, which is
@@ skipping 39 matching lines @@
   // of its owned RootWindowControllers relies on the value.
   display_controller_->Shutdown();
   display_controller_.reset();
   screen_position_controller_.reset();
 
   // Delete the activation controller after other controllers and launcher
   // because they might have registered ActivationChangeObserver.
   activation_controller_.reset();
 
 #if defined(OS_CHROMEOS)
-  if (display_change_observer_.get())
+  if (display_change_observer_)
     output_configurator_->RemoveObserver(display_change_observer_.get());
-  if (output_configurator_animation_.get())
+  if (output_configurator_animation_)
     output_configurator_->RemoveObserver(output_configurator_animation_.get());
-  if (display_error_observer_.get())
+  if (display_error_observer_)
     output_configurator_->RemoveObserver(display_error_observer_.get());
   base::MessagePumpAuraX11::Current()->RemoveDispatcherForRootWindow(
       output_configurator());
 #endif  // defined(OS_CHROMEOS)
 
   DCHECK(instance_ == this);
   instance_ = NULL;
 }
 
 // static
@@ skipping 223 matching lines @@
                                 gfx::SCREEN_TYPE_ALTERNATE));
   AddPreTargetHandler(tooltip_controller_.get());
 
   event_client_.reset(new internal::EventClientImpl);
 
   InitRootWindowController(root_window_controller);
 
   // This controller needs to be set before SetupManagedWindowMode.
   desktop_background_controller_.reset(new DesktopBackgroundController());
   user_wallpaper_delegate_.reset(delegate_->CreateUserWallpaperDelegate());
-  if (!user_wallpaper_delegate_.get())
+  if (!user_wallpaper_delegate_)
     user_wallpaper_delegate_.reset(new DummyUserWallpaperDelegate());
 
   // StatusAreaWidget uses Shell's CapsLockDelegate.
   caps_lock_delegate_.reset(delegate_->CreateCapsLockDelegate());
 
   if (!command_line->HasSwitch(views::corewm::switches::kNoDropShadows)) {
     resize_shadow_controller_.reset(new internal::ResizeShadowController());
     shadow_controller_.reset(
         new views::corewm::ShadowController(activation_client_));
   }
 
   // Create system_tray_notifier_ before the delegate.
   system_tray_notifier_.reset(new ash::SystemTrayNotifier());
 
   // Initialize system_tray_delegate_ before initializing StatusAreaWidget.
   system_tray_delegate_.reset(delegate()->CreateSystemTrayDelegate());
-  if (!system_tray_delegate_.get())
+  if (!system_tray_delegate_)
     system_tray_delegate_.reset(SystemTrayDelegate::CreateDummyDelegate());
 
   // Creates StatusAreaWidget.
   root_window_controller->InitForPrimaryDisplay();
 
   // Initialize system_tray_delegate_ after StatusAreaWidget is created.
   system_tray_delegate_->Initialize();
 
   display_controller_->InitSecondaryDisplays();
 
@@ skipping 35 matching lines @@
   CHECK(rwc) << "root=" << root
              << ", location:" << location_in_screen.ToString();
   if (rwc)
     rwc->ShowContextMenu(location_in_screen);
 }
 
 void Shell::ToggleAppList(aura::Window* window) {
   // If the context window is not given, show it on the active root window.
   if (!window)
     window = GetActiveRootWindow();
-  if (!app_list_controller_.get())
+  if (!app_list_controller_)
     app_list_controller_.reset(new internal::AppListController);
   app_list_controller_->SetVisible(!app_list_controller_->IsVisible(), window);
 }
 
 bool Shell::GetAppListTargetVisibility() const {
   return app_list_controller_.get() &&
       app_list_controller_->GetTargetVisibility();
 }
 
 aura::Window* Shell::GetAppListWindow() {
@@ skipping 138 matching lines @@
 }
 
 void Shell::SetDimming(bool should_dim) {
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     (*iter)->screen_dimmer()->SetDimming(should_dim);
 }
 
 void Shell::CreateModalBackground(aura::Window* window) {
-  if (!modality_filter_.get()) {
+  if (!modality_filter_) {
     modality_filter_.reset(new internal::SystemModalContainerEventFilter(this));
     AddPreTargetHandler(modality_filter_.get());
   }
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
        iter != controllers.end(); ++iter)
     (*iter)->GetSystemModalLayoutManager(window)->CreateModalBackground();
 }
 
 void Shell::OnModalWindowRemoved(aura::Window* removed) {
@@ skipping 21 matching lines @@
 bool Shell::HasPrimaryStatusArea() {
   ShelfWidget* shelf = GetPrimaryRootWindowController()->shelf();
   return shelf && shelf->status_area_widget();
 }
 
 SystemTray* Shell::GetPrimarySystemTray() {
   return GetPrimaryRootWindowController()->GetSystemTray();
 }
 
 LauncherDelegate* Shell::GetLauncherDelegate() {
-  if (!launcher_delegate_.get()) {
+  if (!launcher_delegate_) {
     launcher_model_.reset(new LauncherModel);
     launcher_delegate_.reset(
         delegate_->CreateLauncherDelegate(launcher_model_.get()));
   }
   return launcher_delegate_.get();
 }
 
 void Shell::InitRootWindowForSecondaryDisplay(aura::RootWindow* root) {
   aura::client::SetFocusClient(root, focus_client_.get());
   internal::RootWindowController* controller =
@@ skipping 38 matching lines @@
   }
   aura::client::SetVisibilityClient(root_window, visibility_controller_.get());
   aura::client::SetDragDropClient(root_window, drag_drop_controller_.get());
   aura::client::SetCaptureClient(root_window, capture_controller_.get());
   aura::client::SetScreenPositionClient(root_window,
                                         screen_position_controller_.get());
   aura::client::SetCursorClient(root_window, &cursor_manager_);
   aura::client::SetTooltipClient(root_window, tooltip_controller_.get());
   aura::client::SetEventClient(root_window, event_client_.get());
 
-  if (nested_dispatcher_controller_.get()) {
+  if (nested_dispatcher_controller_) {
     aura::client::SetDispatcherClient(root_window,
                                       nested_dispatcher_controller_.get());
   }
-  if (user_action_client_.get())
+  if (user_action_client_)
     aura::client::SetUserActionClient(root_window, user_action_client_.get());
 
   root_window->SetCursor(ui::kCursorPointer);
   controller->InitLayoutManagers();
 
   // TODO(oshima): Move the instance to RootWindowController when
   // the extended desktop is enabled by default.
   internal::AlwaysOnTopController* always_on_top_controller =
       new internal::AlwaysOnTopController;
   always_on_top_controller->SetAlwaysOnTopContainer(
@@ skipping 40 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Shell, aura::client::ActivationChangeObserver implementation:
 
 void Shell::OnWindowActivated(aura::Window* gained_active,
                               aura::Window* lost_active) {
   if (gained_active)
     active_root_window_ = gained_active->GetRootWindow();
 }
 
 }  // namespace ash