Adding experimental maximize mode (behind a flag)

chrome/browser/ui/views/frame/app_non_client_frame_view_ash.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 "chrome/browser/ui/views/frame/app_non_client_frame_view_ash.h"
 
 #include "ash/shell_delegate.h"
 #include "ash/wm/workspace/frame_maximize_button.h"
 #include "base/debug/stack_trace.h"
 #include "base/i18n/rtl.h"
@@ skipping 27 matching lines @@
 // resource is updated.
 const int kShadowHeightStretch = -1;
 }
 
 class AppNonClientFrameViewAsh::ControlView
     : public views::View, public views::ButtonListener {
  public:
   explicit ControlView(AppNonClientFrameViewAsh* owner) :
       owner_(owner),
       close_button_(new views::ImageButton(this)),
-      restore_button_(new ash::FrameMaximizeButton(this, owner_))
+      restore_button_(new ash::FrameMaximizeButton(this, owner_)),
+      original_maximize_button_width_(0)

[James Cook, 2013/04/22 22:15:46]

If we're going to do this mode, I think you should make this code (and other
frames) support having a NULL restore_button_.

[Mr4D (OOO till 08-26), 2013/04/23 04:41:28]

Right. As stated in my CL comment: This was a no goal for this time. Somehow I
have the feeling that we do not want this mode ;). But if you think that this is
essential I will of course add the logic (but note that this might have much
spread consequences).

[James Cook, 2013/04/23 18:27:32]

OK. Keep the button hiding the way you have it, but please file a bug for
converting this to skip the construction of the button if we decide to keep this
mode and reference it in a comment.

[Mr4D (OOO till 08-26), 2013/04/23 22:24:00]

Added a TODO(skuhne) comment here to make sure it gets properly changed!

   {
     close_button_->SetAccessibleName(
         l10n_util::GetStringUTF16(IDS_ACCNAME_CLOSE));
     restore_button_->SetAccessibleName(
         l10n_util::GetStringUTF16(IDS_ACCNAME_MAXIMIZE));
 
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 
     int control_base_resource_id = owner->browser_view()->IsOffTheRecord() ?
         IDR_AURA_WINDOW_HEADER_BASE_INCOGNITO_ACTIVE :
         IDR_AURA_WINDOW_HEADER_BASE_ACTIVE;
     control_base_ = rb.GetImageNamed(control_base_resource_id).ToImageSkia();
     shadow_ = rb.GetImageNamed(
         base::i18n::IsRTL() ? IDR_AURA_WINDOW_FULLSCREEN_SHADOW_RTL :
                               IDR_AURA_WINDOW_FULLSCREEN_SHADOW).ToImageSkia();
 
     AddChildView(close_button_);
     AddChildView(restore_button_);
   }
 
   virtual ~ControlView() {}
 
   virtual void Layout() OVERRIDE {
+    if (ash::Shell::IsForcedMaximizeMode()) {
+      // TODO(skuhne): If this experiment would get persued, it would be better
+      // to check here the |restore_button_|'s visibility. Furthermore we
+      // should change |shadow_| to a new bitmap which can host only a single
+      // button.
+      gfx::Size size = restore_button_->bounds().size();
+      if (size.width()) {
+        original_maximize_button_width_ = size.width();
+        size.set_width(0);
+        restore_button_->SetSize(size);
+      }
+    }
     restore_button_->SetPosition(gfx::Point(kShadowStart, 0));
     close_button_->SetPosition(gfx::Point(kShadowStart +
         restore_button_->width() - kButtonOverlap, 0));
   }
 
   virtual void ViewHierarchyChanged(bool is_add, View* parent,
                                     View* child) OVERRIDE {
     if (is_add && child == this) {
       SetButtonImages(restore_button_,
                       IDR_AURA_WINDOW_FULLSCREEN_RESTORE,
                       IDR_AURA_WINDOW_FULLSCREEN_RESTORE_H,
                       IDR_AURA_WINDOW_FULLSCREEN_RESTORE_P);
       restore_button_->SizeToPreferredSize();
 
       SetButtonImages(close_button_,
                       IDR_AURA_WINDOW_FULLSCREEN_CLOSE,
                       IDR_AURA_WINDOW_FULLSCREEN_CLOSE_H,
                       IDR_AURA_WINDOW_FULLSCREEN_CLOSE_P);
       close_button_->SizeToPreferredSize();
     }
   }
 
   virtual gfx::Size GetPreferredSize() OVERRIDE {
-    return gfx::Size(shadow_->width(),
+    return gfx::Size(shadow_->width() - original_maximize_button_width_,
                      shadow_->height() + kShadowHeightStretch);
   }
 
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE {
     canvas->TileImageInt(*control_base_,
         base::i18n::IsRTL() ? 0 : restore_button_->x(),
         restore_button_->y(),
         restore_button_->width() - kButtonOverlap + close_button_->width(),
         restore_button_->height());
 
@@ skipping 40 matching lines @@
     button->SetImage(views::CustomButton::STATE_PRESSED,
                      theme_provider->GetImageSkiaNamed(pushed_image_id));
   }
 
   AppNonClientFrameViewAsh* owner_;
   views::ImageButton* close_button_;
   views::ImageButton* restore_button_;
   const gfx::ImageSkia* control_base_;
   const gfx::ImageSkia* shadow_;
 
+  // The original size of the maximize button.
+  int original_maximize_button_width_;
+
   DISALLOW_COPY_AND_ASSIGN(ControlView);
 };
 
 // Observer to detect when the browser frame widget closes so we can clean
 // up our ControlView. Because we can be closed via a keyboard shortcut we
 // are not guaranteed to run AppNonClientFrameView's Close() or Restore().
 class AppNonClientFrameViewAsh::FrameObserver : public views::WidgetObserver {
  public:
   explicit FrameObserver(AppNonClientFrameViewAsh* owner) : owner_(owner) {}
   virtual ~FrameObserver() {}
@@ skipping 113 matching lines @@
       base::i18n::IsRTL() ? 0 : (width() - preferred.width()), 0,
       preferred.width(), preferred.height());
 }
 
 void AppNonClientFrameViewAsh::CloseControlWidget() {
   if (control_widget_) {
     control_widget_->Close();
     control_widget_ = NULL;
   }
 }