Update the maximize button when size constraints change.

ui/views/window/custom_frame_view.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 "ui/views/window/custom_frame_view.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/strings/utf_string_conversions.h"
@@ skipping 71 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // CustomFrameView, public:
 
 CustomFrameView::CustomFrameView()
     : frame_(NULL),
       window_icon_(NULL),
       minimize_button_(NULL),
       maximize_button_(NULL),
       restore_button_(NULL),
       close_button_(NULL),
-      should_show_maximize_button_(false),
       frame_background_(new FrameBackground()),
       minimum_title_bar_x_(0),
       maximum_title_bar_x_(-1) {
 }
 
 CustomFrameView::~CustomFrameView() {
 }
 
 void CustomFrameView::Init(Widget* frame) {
   frame_ = frame;
 
   close_button_ = InitWindowCaptionButton(IDS_APP_ACCNAME_CLOSE,
       IDR_CLOSE, IDR_CLOSE_H, IDR_CLOSE_P);
   minimize_button_ = InitWindowCaptionButton(IDS_APP_ACCNAME_MINIMIZE,
       IDR_MINIMIZE, IDR_MINIMIZE_H, IDR_MINIMIZE_P);
   maximize_button_ = InitWindowCaptionButton(IDS_APP_ACCNAME_MAXIMIZE,
       IDR_MAXIMIZE, IDR_MAXIMIZE_H, IDR_MAXIMIZE_P);
   restore_button_ = InitWindowCaptionButton(IDS_APP_ACCNAME_RESTORE,
       IDR_RESTORE, IDR_RESTORE_H, IDR_RESTORE_P);
 
-  should_show_maximize_button_ = frame_->widget_delegate()->CanMaximize();
-
   if (frame_->widget_delegate()->ShouldShowWindowIcon()) {
     window_icon_ = new ImageButton(this);
     AddChildView(window_icon_);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CustomFrameView, NonClientFrameView implementation:
 
 gfx::Rect CustomFrameView::GetBoundsForClientView() const {
@@ skipping 52 matching lines @@
 
 void CustomFrameView::GetWindowMask(const gfx::Size& size,
                                     gfx::Path* window_mask) {
   DCHECK(window_mask);
   if (frame_->IsMaximized() || !ShouldShowTitleBarAndBorder())
     return;
 
   GetDefaultWindowMask(size, window_mask);
 }
 
 void CustomFrameView::ResetWindowControls() {

[sky, 2014/09/09 15:42:32]

Currently ResetWindowControls is:
  // Tells the window controls as rendered by the NonClientView to reset
  // themselves to a normal state. This happens in situations where the
  // containing window does not receive a normal sequences of messages that
  // would lead to the controls returning to this normal state naturally, e.g.
  // when the window is maximized, minimized or restored.

Not you're changing it to mean both this and that the sizeconstraints may have
changed. I think it clearer to keep the existing meaning and add a new function,
SizeConstraintsChanged that gets the new behavior. This way all the existing
ResetWindowControls don't need the additional layout.

[jackhou1, 2014/09/10 00:49:15]

Done.

Is it okay to have an empty implementation in NonClientFrameView? If you prefer,
I can add leave it abstract like ResetWindowControls and update all the
subclasses.

   restore_button_->SetState(CustomButton::STATE_NORMAL);
   minimize_button_->SetState(CustomButton::STATE_NORMAL);
   maximize_button_->SetState(CustomButton::STATE_NORMAL);
   // The close button isn't affected by this constraint.
+
+  LayoutWindowControls();
 }
 
 void CustomFrameView::UpdateWindowIcon() {
   if (window_icon_)
     window_icon_->SchedulePaint();
 }
 
 void CustomFrameView::UpdateWindowTitle() {
   if (frame_->widget_delegate()->ShouldShowWindowTitle())
     SchedulePaintInRect(title_bounds_);
@@ skipping 393 matching lines @@
 ImageButton* CustomFrameView::GetImageButton(views::FrameButton frame_button) {
   ImageButton* button = NULL;
   switch (frame_button) {
     case views::FRAME_BUTTON_MINIMIZE: {
       button = minimize_button_;
       break;
     }
     case views::FRAME_BUTTON_MAXIMIZE: {
       bool is_restored = !frame_->IsMaximized() && !frame_->IsMinimized();
       button = is_restored ? maximize_button_ : restore_button_;
-      if (!should_show_maximize_button_) {
-        // If we should not show the maximize/restore button, then we return
-        // NULL as we don't want this button to become visible and to be laid
-        // out.
-        button->SetVisible(false);
+      // If we should not show the maximize/restore button, then we return
+      // NULL as we don't want this button to become visible and to be laid
+      // out.
+      bool should_show = frame_->widget_delegate()->CanMaximize();
+      button->SetVisible(should_show);
+      if (!should_show)
         return NULL;
-      }
+
       break;
     }
     case views::FRAME_BUTTON_CLOSE: {
       button = close_button_;
       break;
     }
   }
   return button;
 }
 
 }  // namespace views