Name widget members consistently in app window code.

These were sometimes named window and sometimes names frame. Other
things are more obviously windows and frames, so now widgets are called
widgets.

BUG=None.

Review URL: https://codereview.chromium.org/204313004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@258273 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 69 insertions, 94 deletions

diff --git a/apps/ui/views/app_window_frame_view.cc b/apps/ui/views/app_window_frame_view.cc
index 96ca892..e1c399f 100644
--- a/apps/ui/views/app_window_frame_view.cc
+++ b/apps/ui/views/app_window_frame_view.cc
@@ -39,7 +39,7 @@ const char AppWindowFrameView::kViewClassName[] =
 
 AppWindowFrameView::AppWindowFrameView(NativeAppWindow* window)
     : window_(window),
-      frame_(NULL),
+      widget_(NULL),
       close_button_(NULL),
       maximize_button_(NULL),
       restore_button_(NULL),
@@ -50,13 +50,13 @@ AppWindowFrameView::AppWindowFrameView(NativeAppWindow* window)
 
 AppWindowFrameView::~AppWindowFrameView() {}
 
-void AppWindowFrameView::Init(views::Widget* frame,
+void AppWindowFrameView::Init(views::Widget* widget,
                               const SkColor& frame_color,
                               int resize_inside_bounds_size,
                               int resize_outside_bounds_size,
                               int resize_outside_scale_for_touch,
                               int resize_area_corner_size) {
-  frame_ = frame;
+  widget_ = widget;
   frame_color_ = frame_color;
   resize_inside_bounds_size_ = resize_inside_bounds_size;
   resize_outside_bounds_size_ = resize_outside_bounds_size;
@@ -125,7 +125,7 @@ void AppWindowFrameView::Init(views::Widget* frame,
 // views::NonClientFrameView implementation.
 
 gfx::Rect AppWindowFrameView::GetBoundsForClientView() const {
-  if (window_->IsFrameless() || frame_->IsFullscreen())
+  if (window_->IsFrameless() || widget_->IsFullscreen())
     return bounds();
   return gfx::Rect(
       0, kCaptionHeight, width(), std::max(0, height() - kCaptionHeight));
@@ -154,7 +154,7 @@ gfx::Rect AppWindowFrameView::GetWindowBoundsForClientBounds(
 }
 
 int AppWindowFrameView::NonClientHitTest(const gfx::Point& point) {
-  if (frame_->IsFullscreen())
+  if (widget_->IsFullscreen())
     return HTCLIENT;
 
   gfx::Rect expanded_bounds = bounds();
@@ -170,12 +170,12 @@ int AppWindowFrameView::NonClientHitTest(const gfx::Point& point) {
 
   // Check the frame first, as we allow a small area overlapping the contents
   // to be used for resize handles.
-  bool can_ever_resize = frame_->widget_delegate()
-                             ? frame_->widget_delegate()->CanResize()
+  bool can_ever_resize = widget_->widget_delegate()
+                             ? widget_->widget_delegate()->CanResize()
                              : false;
   // Don't allow overlapping resize handles when the window is maximized or
   // fullscreen, as it can't be resized in those states.
-  int resize_border = (frame_->IsMaximized() || frame_->IsFullscreen())
+  int resize_border = (widget_->IsMaximized() || widget_->IsFullscreen())
                           ? 0
                           : resize_inside_bounds_size_;
   int frame_component = GetHTComponentForFrame(point,
@@ -195,7 +195,7 @@ int AppWindowFrameView::NonClientHitTest(const gfx::Point& point) {
       return HTCAPTION;
   }
 
-  int client_component = frame_->client_view()->NonClientHitTest(point);
+  int client_component = widget_->client_view()->NonClientHitTest(point);
   if (client_component != HTNOWHERE)
     return client_component;
 
@@ -227,9 +227,9 @@ void AppWindowFrameView::GetWindowMask(const gfx::Size& size,
 // views::View implementation.
 
 gfx::Size AppWindowFrameView::GetPreferredSize() {
-  gfx::Size pref = frame_->client_view()->GetPreferredSize();
+  gfx::Size pref = widget_->client_view()->GetPreferredSize();
   gfx::Rect bounds(0, 0, pref.width(), pref.height());
-  return frame_->non_client_view()
+  return widget_->non_client_view()
       ->GetWindowBoundsForClientBounds(bounds)
       .size();
 }
@@ -247,8 +247,8 @@ void AppWindowFrameView::Layout() {
                            close_size.width(),
                            close_size.height());
 
-  bool can_ever_resize = frame_->widget_delegate()
-                             ? frame_->widget_delegate()->CanResize()
+  bool can_ever_resize = widget_->widget_delegate()
+                             ? widget_->widget_delegate()->CanResize()
                              : false;
   maximize_button_->SetEnabled(can_ever_resize);
   gfx::Size maximize_size = maximize_button_->GetPreferredSize();
@@ -264,7 +264,7 @@ void AppWindowFrameView::Layout() {
       restore_size.width(),
       restore_size.height());
 
-  bool maximized = frame_->IsMaximized();
+  bool maximized = widget_->IsMaximized();
   maximize_button_->SetVisible(!maximized);
   restore_button_->SetVisible(maximized);
   if (maximized)
@@ -313,7 +313,7 @@ void AppWindowFrameView::OnPaint(gfx::Canvas* canvas) {
 const char* AppWindowFrameView::GetClassName() const { return kViewClassName; }
 
 gfx::Size AppWindowFrameView::GetMinimumSize() {
-  gfx::Size min_size = frame_->client_view()->GetMinimumSize();
+  gfx::Size min_size = widget_->client_view()->GetMinimumSize();
   if (window_->IsFrameless())
     return min_size;
 
@@ -330,7 +330,7 @@ gfx::Size AppWindowFrameView::GetMinimumSize() {
 }
 
 gfx::Size AppWindowFrameView::GetMaximumSize() {
-  gfx::Size max_size = frame_->client_view()->GetMaximumSize();
+  gfx::Size max_size = widget_->client_view()->GetMaximumSize();
 
   // Add to the client maximum size the height of any title bar and borders.
   gfx::Size client_size = GetBoundsForClientView().size();
@@ -348,13 +348,13 @@ void AppWindowFrameView::ButtonPressed(views::Button* sender,
                                        const ui::Event& event) {
   DCHECK(!window_->IsFrameless());
   if (sender == close_button_)
-    frame_->Close();
+    widget_->Close();
   else if (sender == maximize_button_)
-    frame_->Maximize();
+    widget_->Maximize();
   else if (sender == restore_button_)
-    frame_->Restore();
+    widget_->Restore();
   else if (sender == minimize_button_)
-    frame_->Minimize();
+    widget_->Minimize();
 }
 
 }  // namespace apps
diff --git a/apps/ui/views/app_window_frame_view.h b/apps/ui/views/app_window_frame_view.h
index 2be6161..69e84e9 100644
--- a/apps/ui/views/app_window_frame_view.h
+++ b/apps/ui/views/app_window_frame_view.h
@@ -40,10 +40,10 @@ class AppWindowFrameView : public views::NonClientFrameView,
   explicit AppWindowFrameView(NativeAppWindow* window);
   virtual ~AppWindowFrameView();
 
-  // Initializes this for the window |frame|. Sets the number of pixels for
-  // which a click is interpreted as a resize for the inner and outer border of
-  // the window and the lower-right corner resize handle.
-  void Init(views::Widget* frame,
+  // Initializes this for |widget|. Sets the number of pixels for which a click
+  // is interpreted as a resize for the inner and outer border of the window
+  // and the lower-right corner resize handle.
+  void Init(views::Widget* widget,
             const SkColor& frame_color,
             int resize_inside_bounds_size,
             int resize_outside_bounds_size,
@@ -75,7 +75,7 @@ class AppWindowFrameView : public views::NonClientFrameView,
                              const ui::Event& event) OVERRIDE;
 
   NativeAppWindow* window_;
-  views::Widget* frame_;
+  views::Widget* widget_;
   SkColor frame_color_;
   views::ImageButton* close_button_;
   views::ImageButton* maximize_button_;
diff --git a/apps/ui/views/native_app_window_views.cc b/apps/ui/views/native_app_window_views.cc
index 97e2cbb..304b1cf 100644
--- a/apps/ui/views/native_app_window_views.cc
+++ b/apps/ui/views/native_app_window_views.cc
@@ -26,7 +26,7 @@ namespace apps {
 NativeAppWindowViews::NativeAppWindowViews()
     : app_window_(NULL),
       web_view_(NULL),
-      window_(NULL),
+      widget_(NULL),
       frameless_(false),
       transparent_background_(false),
       resizable_(false) {}
@@ -43,11 +43,11 @@ void NativeAppWindowViews::Init(AppWindow* app_window,
       create_params.GetContentMaximumSize(gfx::Insets()));
   Observe(app_window_->web_contents());
 
-  window_ = new views::Widget;
+  widget_ = new views::Widget;
   InitializeWindow(app_window, create_params);
 
   OnViewWasResized();
-  window_->AddObserver(this);
+  widget_->AddObserver(this);
 }
 
 NativeAppWindowViews::~NativeAppWindowViews() {
@@ -62,35 +62,33 @@ void NativeAppWindowViews::InitializeWindow(
   init_params.delegate = this;
   init_params.top_level = true;
   init_params.keep_on_top = create_params.always_on_top;
-  window_->Init(init_params);
-  window_->CenterWindow(
+  widget_->Init(init_params);
+  widget_->CenterWindow(
       create_params.GetInitialWindowBounds(gfx::Insets()).size());
 }
 
 // ui::BaseWindow implementation.
 
-bool NativeAppWindowViews::IsActive() const {
-  return window_->IsActive();
-}
+bool NativeAppWindowViews::IsActive() const { return widget_->IsActive(); }
 
 bool NativeAppWindowViews::IsMaximized() const {
-  return window_->IsMaximized();
+  return widget_->IsMaximized();
 }
 
 bool NativeAppWindowViews::IsMinimized() const {
-  return window_->IsMinimized();
+  return widget_->IsMinimized();
 }
 
 bool NativeAppWindowViews::IsFullscreen() const {
-  return window_->IsFullscreen();
+  return widget_->IsFullscreen();
 }
 
 gfx::NativeWindow NativeAppWindowViews::GetNativeWindow() {
-  return window_->GetNativeWindow();
+  return widget_->GetNativeWindow();
 }
 
 gfx::Rect NativeAppWindowViews::GetRestoredBounds() const {
-  return window_->GetRestoredBounds();
+  return widget_->GetRestoredBounds();
 }
 
 ui::WindowShowState NativeAppWindowViews::GetRestoredState() const {
@@ -103,81 +101,67 @@ ui::WindowShowState NativeAppWindowViews::GetRestoredState() const {
 }
 
 gfx::Rect NativeAppWindowViews::GetBounds() const {
-  return window_->GetWindowBoundsInScreen();
+  return widget_->GetWindowBoundsInScreen();
 }
 
 void NativeAppWindowViews::Show() {
-  if (window_->IsVisible()) {
-    window_->Activate();
+  if (widget_->IsVisible()) {
+    widget_->Activate();
     return;
   }
-  window_->Show();
+  widget_->Show();
 }
 
 void NativeAppWindowViews::ShowInactive() {
-  if (window_->IsVisible())
+  if (widget_->IsVisible())
     return;
 
-  window_->ShowInactive();
+  widget_->ShowInactive();
 }
 
-void NativeAppWindowViews::Hide() {
-  window_->Hide();
-}
+void NativeAppWindowViews::Hide() { widget_->Hide(); }
 
-void NativeAppWindowViews::Close() {
-  window_->Close();
-}
+void NativeAppWindowViews::Close() { widget_->Close(); }
 
-void NativeAppWindowViews::Activate() {
-  window_->Activate();
-}
+void NativeAppWindowViews::Activate() { widget_->Activate(); }
 
-void NativeAppWindowViews::Deactivate() {
-  window_->Deactivate();
-}
+void NativeAppWindowViews::Deactivate() { widget_->Deactivate(); }
 
-void NativeAppWindowViews::Maximize() {
-  window_->Maximize();
-}
+void NativeAppWindowViews::Maximize() { widget_->Maximize(); }
 
-void NativeAppWindowViews::Minimize() {
-  window_->Minimize();
-}
+void NativeAppWindowViews::Minimize() { widget_->Minimize(); }
 
-void NativeAppWindowViews::Restore() {
-  window_->Restore();
-}
+void NativeAppWindowViews::Restore() { widget_->Restore(); }
 
 void NativeAppWindowViews::SetBounds(const gfx::Rect& bounds) {
-  window_->SetBounds(bounds);
+  widget_->SetBounds(bounds);
 }
 
 void NativeAppWindowViews::FlashFrame(bool flash) {
-  window_->FlashFrame(flash);
+  widget_->FlashFrame(flash);
 }
 
 bool NativeAppWindowViews::IsAlwaysOnTop() const {
   // Stub implementation. See also ChromeNativeAppWindowViews.
-  return window_->IsAlwaysOnTop();
+  return widget_->IsAlwaysOnTop();
 }
 
 void NativeAppWindowViews::SetAlwaysOnTop(bool always_on_top) {
-  window_->SetAlwaysOnTop(always_on_top);
+  widget_->SetAlwaysOnTop(always_on_top);
 }
 
 gfx::NativeView NativeAppWindowViews::GetHostView() const {
-  return window_->GetNativeView();
+  return widget_->GetNativeView();
 }
 
 gfx::Point NativeAppWindowViews::GetDialogPosition(const gfx::Size& size) {
-  gfx::Size app_window_size = window_->GetWindowBoundsInScreen().size();
+  gfx::Size app_window_size = widget_->GetWindowBoundsInScreen().size();
   return gfx::Point(app_window_size.width() / 2 - size.width() / 2,
                     app_window_size.height() / 2 - size.height() / 2);
 }
 
 gfx::Size NativeAppWindowViews::GetMaximumDialogSize() {
-  return window_->GetWindowBoundsInScreen().size();
+  return widget_->GetWindowBoundsInScreen().size();
 }
 
 void NativeAppWindowViews::AddObserver(
@@ -233,17 +217,13 @@ void NativeAppWindowViews::SaveWindowPlacement(const gfx::Rect& bounds,
 }
 
 void NativeAppWindowViews::DeleteDelegate() {
-  window_->RemoveObserver(this);
+  widget_->RemoveObserver(this);
   app_window_->OnNativeClose();
 }
 
-views::Widget* NativeAppWindowViews::GetWidget() {
-  return window_;
-}
+views::Widget* NativeAppWindowViews::GetWidget() { return widget_; }
 
-const views::Widget* NativeAppWindowViews::GetWidget() const {
-  return window_;
-}
+const views::Widget* NativeAppWindowViews::GetWidget() const { return widget_; }
 
 views::View* NativeAppWindowViews::GetContentsView() {
   return this;
@@ -334,12 +314,12 @@ void NativeAppWindowViews::OnFocus() {
 
 void NativeAppWindowViews::SetFullscreen(int fullscreen_types) {
   // Stub implementation. See also ChromeNativeAppWindowViews.
-  window_->SetFullscreen(fullscreen_types != AppWindow::FULLSCREEN_TYPE_NONE);
+  widget_->SetFullscreen(fullscreen_types != AppWindow::FULLSCREEN_TYPE_NONE);
 }
 
 bool NativeAppWindowViews::IsFullscreenOrPending() const {
   // Stub implementation. See also ChromeNativeAppWindowViews.
-  return window_->IsFullscreen();
+  return widget_->IsFullscreen();
 }
 
 bool NativeAppWindowViews::IsDetached() const {
@@ -347,13 +327,9 @@ bool NativeAppWindowViews::IsDetached() const {
   return false;
 }
 
-void NativeAppWindowViews::UpdateWindowIcon() {
-  window_->UpdateWindowIcon();
-}
+void NativeAppWindowViews::UpdateWindowIcon() { widget_->UpdateWindowIcon(); }
 
-void NativeAppWindowViews::UpdateWindowTitle() {
-  window_->UpdateWindowTitle();
-}
+void NativeAppWindowViews::UpdateWindowTitle() { widget_->UpdateWindowTitle(); }
 
 void NativeAppWindowViews::UpdateBadgeIcon() {
   // Stub implementation. See also ChromeNativeAppWindowViews.
@@ -400,8 +376,7 @@ gfx::Insets NativeAppWindowViews::GetFrameInsets() const {
   // than 1000x1000px, so this should be big enough.
   gfx::Rect client_bounds = gfx::Rect(1000, 1000);
   gfx::Rect window_bounds =
-      window_->non_client_view()->GetWindowBoundsForClientBounds(
-          client_bounds);
+      widget_->non_client_view()->GetWindowBoundsForClientBounds(client_bounds);
   return window_bounds.InsetsFrom(client_bounds);
 }
 
diff --git a/apps/ui/views/native_app_window_views.h b/apps/ui/views/native_app_window_views.h
index 217a465..283e7c1 100644
--- a/apps/ui/views/native_app_window_views.h
+++ b/apps/ui/views/native_app_window_views.h
@@ -52,19 +52,19 @@ class NativeAppWindowViews : public NativeAppWindow,
   void Init(AppWindow* app_window,
             const AppWindow::CreateParams& create_params);
 
-  void set_window_for_testing(views::Widget* window) { window_ = window; }
+  void set_window_for_testing(views::Widget* window) { widget_ = window; }
   void set_web_view_for_testing(views::WebView* view) { web_view_ = view; }
 
  protected:
   AppWindow* app_window() { return app_window_; }
   const AppWindow* app_window() const { return app_window_; }
 
-  views::Widget* window() { return window_; }
-  const views::Widget* window() const { return window_; }
+  views::Widget* widget() { return widget_; }
+  const views::Widget* widget() const { return widget_; }
 
   views::WebView* web_view() { return web_view_; }
 
-  // Initializes |window_| for |app_window|.
+  // Initializes |widget_| for |app_window|.
   virtual void InitializeWindow(AppWindow* app_window,
                                 const AppWindow::CreateParams& create_params);
 
@@ -170,7 +170,7 @@ class NativeAppWindowViews : public NativeAppWindow,
 
   AppWindow* app_window_;  // Not owned.
   views::WebView* web_view_;
-  views::Widget* window_;
+  views::Widget* widget_;
 
   scoped_ptr<SkRegion> draggable_region_;