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

ash/wm/workspace/frame_maximize_button.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/frame_maximize_button.h"
 
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
@@ skipping 86 matching lines @@
   // Before the window gets destroyed, the maximizer dialog needs to be shut
   // down since it would otherwise call into a deleted object.
   maximizer_.reset();
   if (widget_)
     OnWindowDestroying(widget_->GetNativeWindow());
 }
 
 void FrameMaximizeButton::SnapButtonHovered(SnapType type) {
   // Make sure to only show hover operations when no button is pressed and
   // a similar snap operation in progress does not get re-applied.
-  if (is_snap_enabled_ || (type == snap_type_ && snap_sizer_.get()))
+  if (is_snap_enabled_ || (type == snap_type_ && snap_sizer_))
     return;
   // Prime the mouse location with the center of the (local) button.
   press_location_ = gfx::Point(width() / 2, height() / 2);
   // Then get an adjusted mouse position to initiate the effect.
   gfx::Point location = press_location_;
   switch (type) {
     case SNAP_LEFT:
       location.set_x(location.x() - width());
       break;
     case SNAP_RIGHT:
@@ skipping 62 matching lines @@
     CHECK_EQ(widget_->GetNativeWindow(), window);
     widget_->GetNativeWindow()->RemoveObserver(this);
     widget_->RemoveObserver(this);
     widget_ = NULL;
   }
 }
 
 void FrameMaximizeButton::OnWidgetActivationChanged(views::Widget* widget,
                                                     bool active) {
   // Upon losing focus, the control bubble should hide.
-  if (!active && maximizer_.get())
+  if (!active && maximizer_)
     maximizer_.reset();
 }
 
 bool FrameMaximizeButton::OnMousePressed(const ui::MouseEvent& event) {
   // If we are already in a mouse click / drag operation, a second button down
   // call will cancel (this addresses crbug.com/143755).
   if (is_snap_enabled_) {
     Cancel(false);
   } else {
     is_snap_enabled_ = event.IsOnlyLeftMouseButton();
     if (is_snap_enabled_)
       ProcessStartEvent(event);
   }
   ImageButton::OnMousePressed(event);
   return true;
 }
 
 void FrameMaximizeButton::OnMouseEntered(const ui::MouseEvent& event) {
   ImageButton::OnMouseEntered(event);
-  if (!maximizer_.get()) {
+  if (!maximizer_) {
     DCHECK(GetWidget());
     if (!widget_) {
       widget_ = frame_->GetWidget();
       widget_->GetNativeWindow()->AddObserver(this);
       widget_->AddObserver(this);
     }
     maximizer_.reset(new MaximizeBubbleController(
         this,
         GetMaximizeBubbleFrameState(),
         bubble_appearance_delay_ms_));
   }
 }
 
 void FrameMaximizeButton::OnMouseExited(const ui::MouseEvent& event) {
   ImageButton::OnMouseExited(event);
   // Remove the bubble menu when the button is not pressed and the mouse is not
   // within the bubble.
-  if (!is_snap_enabled_ && maximizer_.get()) {
+  if (!is_snap_enabled_ && maximizer_) {
     if (maximizer_->GetBubbleWindow()) {
       gfx::Point screen_location = Shell::GetScreen()->GetCursorScreenPoint();
       if (!maximizer_->GetBubbleWindow()->GetBoundsInScreen().Contains(
               screen_location)) {
         maximizer_.reset();
         // Make sure that all remaining snap hover states get removed.
         SnapButtonHovered(SNAP_NONE);
       }
     } else {
       // The maximize dialog does not show up immediately after creating the
@@ skipping 63 matching lines @@
       return;
     }
   }
 
   ImageButton::OnGestureEvent(event);
 }
 
 void FrameMaximizeButton::ProcessStartEvent(const ui::LocatedEvent& event) {
   DCHECK(is_snap_enabled_);
   // Prepare the help menu.
-  if (!maximizer_.get()) {
+  if (!maximizer_) {
     maximizer_.reset(new MaximizeBubbleController(
         this,
         GetMaximizeBubbleFrameState(),
         bubble_appearance_delay_ms_));
   } else {
     // If the menu did not show up yet, we delay it even a bit more.
     maximizer_->DelayCreation();
   }
   snap_sizer_.reset(NULL);
   InstallEventFilter();
@@ skipping 49 matching lines @@
     is_snap_enabled_ = false;
     snap_sizer_.reset();
   }
   phantom_window_.reset();
   snap_type_ = SNAP_NONE;
   update_timer_.Stop();
   SchedulePaint();
 }
 
 void FrameMaximizeButton::InstallEventFilter() {
-  if (escape_event_filter_.get())
+  if (escape_event_filter_)
     return;
 
   escape_event_filter_.reset(new EscapeEventFilter(this));
 }
 
 void FrameMaximizeButton::UninstallEventFilter() {
   escape_event_filter_.reset(NULL);
 }
 
 void FrameMaximizeButton::UpdateSnapFromEventLocation() {
   // If the drag threshold has been exceeded the snap location is up to date.
   if (exceeded_drag_threshold_)
     return;
   exceeded_drag_threshold_ = true;
   UpdateSnap(press_location_, false, press_is_gesture_);
 }
 
 void FrameMaximizeButton::UpdateSnap(const gfx::Point& location,
                                      bool select_default,
                                      bool is_touch) {
   SnapType type = SnapTypeForLocation(location);
   if (type == snap_type_) {
-    if (snap_sizer_.get()) {
+    if (snap_sizer_) {
       snap_sizer_->Update(LocationForSnapSizer(location));
       phantom_window_->Show(ScreenAsh::ConvertRectToScreen(
           frame_->GetWidget()->GetNativeView()->parent(),
           snap_sizer_->target_bounds()));
     }
     return;
   }
 
   snap_type_ = type;
   snap_sizer_.reset();
@@ skipping 10 matching lines @@
     SnapSizer::InputType input_type =
         is_touch ? SnapSizer::TOUCH_MAXIMIZE_BUTTON_INPUT :
                    SnapSizer::OTHER_INPUT;
     snap_sizer_.reset(new SnapSizer(frame_->GetWidget()->GetNativeWindow(),
                                     LocationForSnapSizer(location),
                                     snap_edge,
                                     input_type));
     if (select_default)
       snap_sizer_->SelectDefaultSizeAndDisableResize();
   }
-  if (!phantom_window_.get()) {
+  if (!phantom_window_) {
     phantom_window_.reset(new internal::PhantomWindowController(
                               frame_->GetWidget()->GetNativeWindow()));
   }
-  if (maximizer_.get()) {
+  if (maximizer_) {
     phantom_window_->set_phantom_below_window(maximizer_->GetBubbleWindow());
     maximizer_->SetSnapType(snap_type_);
   }
   phantom_window_->Show(
       ScreenBoundsForType(snap_type_, *snap_sizer_.get()));
 }
 
 SnapType FrameMaximizeButton::SnapTypeForLocation(
     const gfx::Point& location) const {
   MaximizeBubbleFrameState maximize_type = GetMaximizeBubbleFrameState();
@@ skipping 149 matching lines @@
     return FRAME_STATE_SNAP_LEFT;
   if (bounds.right() == screen.right())
     return FRAME_STATE_SNAP_RIGHT;
   // If we come here, it is likely caused by the fact that the
   // "VerticalResizeDoubleClick" stored a restore rectangle. In that case
   // we allow all maximize operations (and keep the restore rectangle).
   return FRAME_STATE_NONE;
 }
 
 }  // namespace ash