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

ash/wm/workspace/multi_window_resize_controller.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/wm/workspace/multi_window_resize_controller.h"
 
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
@@ skipping 144 matching lines @@
   Hide();
 }
 
 void MultiWindowResizeController::Show(Window* window,
                                        int component,
                                        const gfx::Point& point_in_window) {
   // When the resize widget is showing we ignore Show() requests. Instead we
   // only care about mouse movements from MouseWatcher. This is necessary as
   // WorkspaceEventHandler only sees mouse movements over the windows, not all
   // windows or over the desktop.
-  if (resize_widget_.get())
+  if (resize_widget_)
     return;
 
   ResizeWindows windows(DetermineWindows(window, component, point_in_window));
   if (IsShowing()) {
     if (windows_.Equals(windows))
       return;  // Over the same windows.
     DelayedHide();
   }
 
   if (!windows.is_valid())
     return;
   Hide();
   windows_ = windows;
   windows_.window1->AddObserver(this);
   windows_.window2->AddObserver(this);
   show_location_in_parent_ = point_in_window;
   Window::ConvertPointToTarget(
       window, window->parent(), &show_location_in_parent_);
   if (show_timer_.IsRunning())
     return;
   show_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(kShowDelayMS),
       this, &MultiWindowResizeController::ShowIfValidMouseLocation);
 }
 
 void MultiWindowResizeController::Hide() {
   hide_timer_.Stop();
-  if (window_resizer_.get())
+  if (window_resizer_)
     return;  // Ignore hides while actively resizing.
 
   if (windows_.window1) {
     windows_.window1->RemoveObserver(this);
     windows_.window1 = NULL;
   }
   if (windows_.window2) {
     windows_.window2->RemoveObserver(this);
     windows_.window2 = NULL;
   }
 
   show_timer_.Stop();
 
-  if (!resize_widget_.get())
+  if (!resize_widget_)
     return;
 
   for (size_t i = 0; i < windows_.other_windows.size(); ++i)
     windows_.other_windows[i]->RemoveObserver(this);
   mouse_watcher_.reset();
   resize_widget_.reset();
   windows_ = ResizeWindows();
 }
 
 void MultiWindowResizeController::MouseMovedOutOfHost() {
@@ skipping 248 matching lines @@
     // If the mouse is over the resizer we need to remove observers on any of
     // the |other_windows|. If we start another resize we'll recalculate the
     // |other_windows| and invoke AddObserver() as necessary.
     for (size_t i = 0; i < windows_.other_windows.size(); ++i)
       windows_.other_windows[i]->RemoveObserver(this);
     windows_.other_windows.clear();
   }
 }
 
 void MultiWindowResizeController::CancelResize() {
-  if (!window_resizer_.get())
+  if (!window_resizer_)
     return;  // Happens if window was destroyed and we nuked the WindowResizer.
   window_resizer_->RevertDrag();
   window_resizer_.reset();
   Hide();
 }
 
 gfx::Rect MultiWindowResizeController::CalculateResizeWidgetBounds(
     const gfx::Point& location_in_parent) const {
   gfx::Size pref = resize_widget_->GetContentsView()->GetPreferredSize();
   int x = 0, y = 0;
@@ skipping 10 matching lines @@
         x + pref.height() / 2 > windows_.window2->bounds().right()) {
       x = location_in_parent.x() - kResizeWidgetPadding - pref.width();
     }
     y = windows_.window1->bounds().bottom() - pref.height() / 2;
   }
   return gfx::Rect(x, y, pref.width(), pref.height());
 }
 
 bool MultiWindowResizeController::IsOverWindows(
     const gfx::Point& location_in_screen) const {
-  if (window_resizer_.get())
+  if (window_resizer_)
     return true;  // Ignore hides while actively resizing.
 
   if (resize_widget_->GetWindowBoundsInScreen().Contains(location_in_screen))
     return true;
 
   int hit1, hit2;
   if (windows_.direction == TOP_BOTTOM) {
     hit1 = HTBOTTOM;
     hit2 = HTTOP;
   } else {
@@ skipping 14 matching lines @@
 
   gfx::Point window_loc(location_in_screen);
   aura::Window::ConvertPointToTarget(
       window->GetRootWindow(), window, &window_loc);
   return window->HitTest(window_loc) &&
       window->delegate()->GetNonClientComponent(window_loc) == component;
 }
 
 }  // namespace internal
 }  // namespace ash