[Refactor] Cache the views::Widget* that the FrameMaximizeButton acts on

ash/wm/caption_buttons/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/caption_buttons/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 64 matching lines @@
     ui::KeyEvent* event) {
   if (event->type() == ui::ET_KEY_PRESSED &&
       event->key_code() == ui::VKEY_ESCAPE) {
     button_->Cancel(false);
   }
 }
 
 // FrameMaximizeButton ---------------------------------------------------------
 
 FrameMaximizeButton::FrameMaximizeButton(views::ButtonListener* listener,
-                                         views::NonClientFrameView* frame)
+                                         views::Widget* frame)
     : ImageButton(listener),
       frame_(frame),
+      observing_frame_(false),
       is_snap_enabled_(false),
       exceeded_drag_threshold_(false),
-      widget_(NULL),
       press_is_gesture_(false),
       snap_type_(SNAP_NONE),
       bubble_appearance_delay_ms_(kBubbleAppearanceDelayMS) {
   // TODO(sky): nuke this. It's temporary while we don't have good images.
   SetImageAlignment(ALIGN_LEFT, ALIGN_BOTTOM);
 
   if (ash::Shell::IsForcedMaximizeMode())
     views::View::SetVisible(false);
 }
 
 FrameMaximizeButton::~FrameMaximizeButton() {
   // 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());
+  if (observing_frame_)
+    OnWindowDestroying(frame_->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_))
     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.
@@ skipping 57 matching lines @@
 }
 
 void FrameMaximizeButton::OnWindowPropertyChanged(aura::Window* window,
                                                   const void* key,
                                                   intptr_t old) {
   Cancel(false);
 }
 
 void FrameMaximizeButton::OnWindowDestroying(aura::Window* window) {
   maximizer_.reset();
-  if (widget_) {
-    CHECK_EQ(widget_->GetNativeWindow(), window);
-    widget_->GetNativeWindow()->RemoveObserver(this);
-    widget_->RemoveObserver(this);
-    widget_ = NULL;
+  if (observing_frame_) {
+    CHECK_EQ(frame_->GetNativeWindow(), window);
+    frame_->GetNativeWindow()->RemoveObserver(this);
+    frame_->RemoveObserver(this);
+    observing_frame_ = false;
   }
 }
 
 void FrameMaximizeButton::OnWidgetActivationChanged(views::Widget* widget,
                                                     bool active) {
   // Upon losing focus, the control bubble should hide.
   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_) {
     DCHECK(GetWidget());
-    if (!widget_) {
-      widget_ = frame_->GetWidget();
-      widget_->GetNativeWindow()->AddObserver(this);
-      widget_->AddObserver(this);
+    if (!observing_frame_) {
+      observing_frame_ = true;
+      frame_->GetNativeWindow()->AddObserver(this);
+      frame_->AddObserver(this);
     }
     maximizer_.reset(new MaximizeBubbleController(
         this,
         GetMaximizeBubbleFrameState(),
         bubble_appearance_delay_ms_));
   }
 }
 
 void FrameMaximizeButton::OnMouseExited(const ui::MouseEvent& event) {
   ImageButton::OnMouseExited(event);
@@ skipping 183 matching lines @@
 }
 
 void FrameMaximizeButton::UpdateSnap(const gfx::Point& location,
                                      bool select_default,
                                      bool is_touch) {
   SnapType type = SnapTypeForLocation(location);
   if (type == snap_type_) {
     if (snap_sizer_) {
       snap_sizer_->Update(LocationForSnapSizer(location));
       phantom_window_->Show(ScreenAsh::ConvertRectToScreen(
-          frame_->GetWidget()->GetNativeView()->parent(),
+          frame_->GetNativeView()->parent(),
           snap_sizer_->target_bounds()));
     }
     return;
   }
 
   snap_type_ = type;
   snap_sizer_.reset();
   SchedulePaint();
 
   if (snap_type_ == SNAP_NONE) {
     phantom_window_.reset();
     return;
   }
 
   if (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT) {
     SnapSizer::Edge snap_edge = snap_type_ == SNAP_LEFT ?
         SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
     SnapSizer::InputType input_type =
         is_touch ? SnapSizer::TOUCH_MAXIMIZE_BUTTON_INPUT :
                    SnapSizer::OTHER_INPUT;
-    snap_sizer_.reset(new SnapSizer(frame_->GetWidget()->GetNativeWindow(),
+    snap_sizer_.reset(new SnapSizer(frame_->GetNativeWindow(),
                                     LocationForSnapSizer(location),
                                     snap_edge,
                                     input_type));
     if (select_default)
       snap_sizer_->SelectDefaultSizeAndDisableResize();
   }
   if (!phantom_window_) {
     phantom_window_.reset(new internal::PhantomWindowController(
-                              frame_->GetWidget()->GetNativeWindow()));
+                              frame_->GetNativeWindow()));
   }
   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();
   gfx::Vector2d delta(location - press_location_);
   if (!views::View::ExceededDragThreshold(delta))
     return maximize_type != FRAME_STATE_FULL ? SNAP_MAXIMIZE : SNAP_RESTORE;
   if (delta.x() < 0 && delta.y() > delta.x() && delta.y() < -delta.x())
     return maximize_type == FRAME_STATE_SNAP_LEFT ? SNAP_RESTORE : SNAP_LEFT;
   if (delta.x() > 0 && delta.y() > -delta.x() && delta.y() < delta.x())
     return maximize_type == FRAME_STATE_SNAP_RIGHT ? SNAP_RESTORE : SNAP_RIGHT;
   if (delta.y() > 0)
     return SNAP_MINIMIZE;
   return maximize_type != FRAME_STATE_FULL ? SNAP_MAXIMIZE : SNAP_RESTORE;
 }
 
 gfx::Rect FrameMaximizeButton::ScreenBoundsForType(
     SnapType type,
     const SnapSizer& snap_sizer) const {
-  aura::Window* window = frame_->GetWidget()->GetNativeWindow();
+  aura::Window* window = frame_->GetNativeWindow();
   switch (type) {
     case SNAP_LEFT:
     case SNAP_RIGHT:
-      return ScreenAsh::ConvertRectToScreen(
-          frame_->GetWidget()->GetNativeView()->parent(),
-          snap_sizer.target_bounds());
+      return ScreenAsh::ConvertRectToScreen(window->parent(),
+                                            snap_sizer.target_bounds());
     case SNAP_MAXIMIZE:
       return ScreenAsh::ConvertRectToScreen(
           window->parent(),
           ScreenAsh::GetMaximizedWindowBoundsInParent(window));
     case SNAP_MINIMIZE: {
       gfx::Rect rect = GetMinimizeAnimationTargetBoundsInScreen(window);
       if (!rect.IsEmpty()) {
         // PhantomWindowController insets slightly, outset it so the phantom
         // doesn't appear inset.
         rect.Inset(-8, -8);
       }
       return rect;
     }
     case SNAP_RESTORE: {
       const gfx::Rect* restore = GetRestoreBoundsInScreen(window);
-      return restore ?
-          *restore : frame_->GetWidget()->GetWindowBoundsInScreen();
+      return restore ? *restore : frame_->GetWindowBoundsInScreen();
     }
     case SNAP_NONE:
       NOTREACHED();
   }
   return gfx::Rect();
 }
 
 gfx::Point FrameMaximizeButton::LocationForSnapSizer(
     const gfx::Point& location) const {
   gfx::Point result(location);
   views::View::ConvertPointToScreen(this, &result);
   return result;
 }
 
 void FrameMaximizeButton::Snap(const SnapSizer& snap_sizer) {
   ash::Shell* shell = ash::Shell::GetInstance();
-  views::Widget* widget = frame_->GetWidget();
   switch (snap_type_) {
     case SNAP_LEFT:
     case SNAP_RIGHT: {
       shell->delegate()->RecordUserMetricsAction(
           snap_type_ == SNAP_LEFT ?
               ash::UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_LEFT :
               ash::UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_RIGHT);
       // Get the bounds in screen coordinates for restore purposes.
-      gfx::Rect restore = widget->GetWindowBoundsInScreen();
-      if (widget->IsMaximized() || widget->IsFullscreen()) {
-        aura::Window* window = widget->GetNativeWindow();
+      gfx::Rect restore = frame_->GetWindowBoundsInScreen();
+      if (frame_->IsMaximized() || frame_->IsFullscreen()) {
+        aura::Window* window = frame_->GetNativeWindow();
         // In case of maximized we have a restore boundary.
         DCHECK(ash::GetRestoreBoundsInScreen(window));
         // If it was maximized we need to recover the old restore set.
         restore = *ash::GetRestoreBoundsInScreen(window);
 
         // The auto position manager will kick in when this is the only window.
         // To avoid interference with it we tell it temporarily to not change
         // the coordinates of this window.
         wm::WindowSettings* settings = wm::GetWindowSettings(window);
         bool was_managed = settings->window_position_managed();
         settings->set_window_position_managed(false);
 
         // Set the restore size we want to restore to.
         ash::SetRestoreBoundsInScreen(window,
                                       ScreenBoundsForType(snap_type_,
                                                           snap_sizer));
-        widget->Restore();
+        frame_->Restore();
 
         // After the window is where we want it to be we allow the window to be
         // auto managed again.
         settings->set_window_position_managed(was_managed);
       } else {
         // Others might also have set up a restore rectangle already. If so,
         // we should not overwrite the restore rectangle.
         bool restore_set =
-            GetRestoreBoundsInScreen(widget->GetNativeWindow()) != NULL;
-        widget->SetBounds(ScreenBoundsForType(snap_type_, snap_sizer));
+            GetRestoreBoundsInScreen(frame_->GetNativeWindow()) != NULL;
+        frame_->SetBounds(ScreenBoundsForType(snap_type_, snap_sizer));
         if (restore_set)
           break;
       }
       // Remember the widow's bounds for restoration.
-      ash::SetRestoreBoundsInScreen(widget->GetNativeWindow(), restore);
+      ash::SetRestoreBoundsInScreen(frame_->GetNativeWindow(), restore);
       break;
     }
     case SNAP_MAXIMIZE:
-      widget->Maximize();
+      frame_->Maximize();
       shell->delegate()->RecordUserMetricsAction(
           ash::UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE);
       break;
     case SNAP_MINIMIZE:
-      widget->Minimize();
+      frame_->Minimize();
       shell->delegate()->RecordUserMetricsAction(
           ash::UMA_WINDOW_MAXIMIZE_BUTTON_MINIMIZE);
       break;
     case SNAP_RESTORE:
-      widget->Restore();
+      frame_->Restore();
       shell->delegate()->RecordUserMetricsAction(
           ash::UMA_WINDOW_MAXIMIZE_BUTTON_RESTORE);
       break;
     case SNAP_NONE:
       NOTREACHED();
   }
 }
 
 MaximizeBubbleFrameState
 FrameMaximizeButton::GetMaximizeBubbleFrameState() const {
   // When there are no restore bounds, we are in normal mode.
-  if (!ash::GetRestoreBoundsInScreen(
-           frame_->GetWidget()->GetNativeWindow()))
+  if (!ash::GetRestoreBoundsInScreen(frame_->GetNativeWindow()))
     return FRAME_STATE_NONE;
   // The normal maximized test can be used.
-  if (frame_->GetWidget()->IsMaximized())
+  if (frame_->IsMaximized())
     return FRAME_STATE_FULL;
   // For Left/right maximize we need to check the dimensions.
-  gfx::Rect bounds = frame_->GetWidget()->GetWindowBoundsInScreen();
+  gfx::Rect bounds = frame_->GetWindowBoundsInScreen();
   gfx::Rect screen = Shell::GetScreen()->GetDisplayNearestWindow(
-      frame_->GetWidget()->GetNativeView()).work_area();
+      frame_->GetNativeView()).work_area();
   if (bounds.width() < (screen.width() * kMinSnapSizePercent) / 100)
     return FRAME_STATE_NONE;
   // We might still have a horizontally filled window at this point which we
   // treat as no special state.
   if (bounds.y() != screen.y() || bounds.height() != screen.height())
     return FRAME_STATE_NONE;
 
   // We have to be in a maximize mode at this point.
   if (bounds.x() == screen.x())
     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