Make Web Intents picker in Views conform to latest mocks

chrome/browser/ui/views/constrained_window_views.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/constrained_window_views.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/constrained_window_constants.h"
 #include "chrome/browser/ui/constrained_window_tab_helper.h"
 #include "chrome/browser/ui/toolbar/toolbar_model.h"
 #include "chrome/browser/ui/views/constrained_window_frame_simple.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
+#include "content/public/browser/navigation_controller.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_source.h"
+#include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "net/base/net_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 123 matching lines @@
   }
 
   static gfx::ImageSkia* images_[FRAME_PART_IMAGE_COUNT];
 
   DISALLOW_COPY_AND_ASSIGN(VistaWindowResources);
 };
 
 gfx::ImageSkia* XPWindowResources::images_[];
 gfx::ImageSkia* VistaWindowResources::images_[];
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowFrameView
-
 class ConstrainedWindowFrameView : public views::NonClientFrameView,
                                    public views::ButtonListener {
  public:
   explicit ConstrainedWindowFrameView(ConstrainedWindowViews* container);
   virtual ~ConstrainedWindowFrameView();
 
   void UpdateWindowTitle();
 
   // Overridden from views::NonClientFrameView:
   virtual gfx::Rect GetBoundsForClientView() const OVERRIDE;
@@ skipping 99 matching lines @@
 const int kIconMinimumSize = 16;
 // The title text starts 2 px from the right edge of the left frame border.
 const int kTitleLeftSpacing = 2;
 // There is a 5 px gap between the title text and the caption buttons.
 const int kTitleCaptionSpacing = 5;
 
 const SkColor kContentsBorderShadow = SkColorSetARGB(51, 0, 0, 0);
 
 }  // namespace
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowFrameView, public:
-
 ConstrainedWindowFrameView::ConstrainedWindowFrameView(
     ConstrainedWindowViews* container)
     : NonClientFrameView(),
       container_(container),
       close_button_(new views::ImageButton(this)),
       frame_background_(new views::FrameBackground()) {
   InitClass();
   InitWindowResources();
 
   // Constrained windows always use the custom frame - they just have a
@@ skipping 12 matching lines @@
   AddChildView(close_button_);
 }
 
 ConstrainedWindowFrameView::~ConstrainedWindowFrameView() {
 }
 
 void ConstrainedWindowFrameView::UpdateWindowTitle() {
   SchedulePaintInRect(title_bounds_);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowFrameView, views::NonClientFrameView implementation:
-
 gfx::Rect ConstrainedWindowFrameView::GetBoundsForClientView() const {
   return client_view_bounds_;
 }
 
 gfx::Rect ConstrainedWindowFrameView::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) const {
   int top_height = NonClientTopBorderHeight();
   int border_thickness = NonClientBorderThickness();
   return gfx::Rect(std::max(0, client_bounds.x() - border_thickness),
                    std::max(0, client_bounds.y() - top_height),
@@ skipping 28 matching lines @@
   // Fall back to the caption if no other component matches.
   return (window_component == HTNOWHERE) ? HTCAPTION : window_component;
 }
 
 void ConstrainedWindowFrameView::GetWindowMask(const gfx::Size& size,
                                                gfx::Path* window_mask) {
   DCHECK(window_mask);
   views::GetDefaultWindowMask(size, window_mask);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowFrameView, views::View implementation:
-
 void ConstrainedWindowFrameView::OnPaint(gfx::Canvas* canvas) {
   PaintFrameBorder(canvas);
   PaintTitleBar(canvas);
   PaintClientEdge(canvas);
 }
 
 void ConstrainedWindowFrameView::Layout() {
   LayoutWindowControls();
   LayoutTitleBar();
   client_view_bounds_ = CalculateClientAreaBounds(width(), height());
 }
 
 void ConstrainedWindowFrameView::OnThemeChanged() {
   InitWindowResources();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowFrameView, views::ButtonListener implementation:
-
 void ConstrainedWindowFrameView::ButtonPressed(
     views::Button* sender, const ui::Event& event) {
   if (sender == close_button_)
     container_->CloseConstrainedWindow();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowFrameView, private:
-
 int ConstrainedWindowFrameView::NonClientBorderThickness() const {
   return kFrameBorderThickness + kClientEdgeThickness;
 }
 
 int ConstrainedWindowFrameView::NonClientTopBorderHeight() const {
   return std::max(kFrameBorderThickness + IconSize(),
                   kFrameShadowThickness + kCaptionButtonHeightWithPadding) +
       TitlebarBottomThickness();
 }
 
@@ skipping 152 matching lines @@
     if (sender == close_button())
       container_->CloseConstrainedWindow();
   }
 
  private:
   ConstrainedWindowViews* container_;  // not owned
   DISALLOW_COPY_AND_ASSIGN(ConstrainedWindowFrameViewAsh);
 };
 #endif  // defined(USE_ASH)
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowViews, public:
-
 ConstrainedWindowViews::ConstrainedWindowViews(
     content::WebContents* web_contents,
     views::WidgetDelegate* widget_delegate,
-    bool enable_chrome_style)
+    bool enable_chrome_style,
+    const gfx::Insets& client_insets)
     : WebContentsObserver(web_contents),
       web_contents_(web_contents),
+      enable_chrome_style_(enable_chrome_style),
+      client_insets_(client_insets),
       ALLOW_THIS_IN_INITIALIZER_LIST(native_constrained_window_(
-          NativeConstrainedWindow::CreateNativeConstrainedWindow(this))),
-      enable_chrome_style_(enable_chrome_style) {
+          NativeConstrainedWindow::CreateNativeConstrainedWindow(this))) {
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.delegate = widget_delegate;
   params.native_widget = native_constrained_window_->AsNativeWidget();
   params.child = true;
   ConstrainedWindowTabHelper::CreateForWebContents(web_contents);
 
   if (enable_chrome_style_) {
     params.parent_widget = Widget::GetTopLevelWidgetForNativeView(
-        web_contents->GetView()->GetNativeView());
+        web_contents_->GetView()->GetNativeView());
   } else {
-    params.parent = web_contents->GetNativeView();
+    params.parent = web_contents_->GetNativeView();
   }
 
 #if defined(USE_ASH)
   // Ash window headers can be transparent.
   params.transparent = true;
   ash::SetChildWindowVisibilityChangesAnimated(params.GetParent());
   // No animations should get performed on the window since that will re-order
   // the window stack which will then cause many problems.
   if (params.parent && params.parent->parent()) {
     params.parent->parent()->SetProperty(aura::client::kAnimationsDisabledKey,
                                          true);
   }
 #endif
   Init(params);
 
   if (enable_chrome_style_) {
     // Set the dialog background color.
     if (widget_delegate && widget_delegate->AsDialogDelegate()) {
       views::Background* background = views::Background::CreateSolidBackground(
           ConstrainedWindow::GetBackgroundColor());
       views::DialogClientView* dialog_client_view =
           widget_delegate->AsDialogDelegate()->GetDialogClientView();
       if (dialog_client_view)
         dialog_client_view->set_background(background);
     }
-    PositionChromeStyleWindow();
+    PositionChromeStyleWindow(GetRootView()->bounds().size());
+    registrar_.Add(this,
+                   content::NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
+                   content::Source<content::WebContents>(web_contents));
   }
 
   ConstrainedWindowTabHelper* constrained_window_tab_helper =
       ConstrainedWindowTabHelper::FromWebContents(web_contents_);
   constrained_window_tab_helper->AddConstrainedDialog(this);
 #if defined(USE_ASH)
   GetNativeWindow()->SetProperty(ash::kConstrainedWindowKey, true);
 #endif
 }
 
 ConstrainedWindowViews::~ConstrainedWindowViews() {
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowViews, ConstrainedWindow implementation:
-
 void ConstrainedWindowViews::ShowConstrainedWindow() {
   Show();
   FocusConstrainedWindow();
 }
 
 void ConstrainedWindowViews::CloseConstrainedWindow() {
 #if defined(USE_ASH)
   gfx::NativeView view = web_contents_->GetNativeView();
   // Allow the parent to animate again.
   if (view && view->parent())
@@ skipping 25 matching lines @@
 
 void ConstrainedWindowViews::NotifyTabHelperWillClose() {
   if (!web_contents_)
     return;
 
   ConstrainedWindowTabHelper* constrained_window_tab_helper =
       ConstrainedWindowTabHelper::FromWebContents(web_contents_);
   constrained_window_tab_helper->WillClose(this);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowViews, views::Widget overrides:
-
 void ConstrainedWindowViews::CenterWindow(const gfx::Size& size) {
-  Widget::CenterWindow(size);
   if (enable_chrome_style_)
-    PositionChromeStyleWindow();
+    PositionChromeStyleWindow(size);
+  else
+    Widget::CenterWindow(size);
 }
 
 views::NonClientFrameView* ConstrainedWindowViews::CreateNonClientFrameView() {
   if (enable_chrome_style_) {
-    return new ConstrainedWindowFrameSimple(this);
-  } else {
+    ConstrainedWindowFrameSimple* frame =
+        new ConstrainedWindowFrameSimple(this);
+    frame->set_border(views::Border::CreateEmptyBorder(
+        client_insets_.top(),
+        client_insets_.left(),
+        client_insets_.bottom(),
+        client_insets_.right()));
+    return frame;
+  }
 #if defined(USE_ASH)
-    CommandLine* command_line = CommandLine::ForCurrentProcess();
-    if (command_line->HasSwitch(ash::switches::kAuraGoogleDialogFrames))
-      return ash::Shell::GetInstance()->CreateDefaultNonClientFrameView(this);
-    ConstrainedWindowFrameViewAsh* frame = new ConstrainedWindowFrameViewAsh;
-    frame->Init(this);
-    return frame;
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(ash::switches::kAuraGoogleDialogFrames))
+    return ash::Shell::GetInstance()->CreateDefaultNonClientFrameView(this);
+  ConstrainedWindowFrameViewAsh* frame = new ConstrainedWindowFrameViewAsh;
+  frame->Init(this);
+  return frame;
 #endif
-    return new ConstrainedWindowFrameView(this);
-  }
+  return new ConstrainedWindowFrameView(this);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowViews, NativeConstrainedWindowDelegate implementation:
+// static
+gfx::Insets ConstrainedWindowViews::GetDefaultInsets() {
+  const int kHeaderHeight = 26;

[Peter Kasting, 2012/10/16 02:26:53]

Could this value be calculated on the fly by the ConstrainedWindow by asking the
frame view for the client bounds?  If so, it would reflect the actual header
height, which would be more robust if the user had a different system font or
something.

[please use gerrit instead, 2012/10/16 16:29:38]

I have added an enum ConstrainedWindowViews::ChromeStyleClientInsets with two
values: DEFAULT_INSETS and NO_INSETS. ConstrainedWindowFrameSimple checks the
value of container->chrome_style_client_insets() and uses its own knowledge of
its header size to set its own insets. This makes the sizing contained inside of
ConstrainedWindowFrameSimple. Done.

+  return gfx::Insets(
+      ConstrainedWindowConstants::kClientTopPadding + kHeaderHeight,
+      ConstrainedWindowConstants::kHorizontalPadding,
+      ConstrainedWindowConstants::kClientBottomPadding,
+      ConstrainedWindowConstants::kHorizontalPadding);
+}
 
 void ConstrainedWindowViews::OnNativeConstrainedWindowDestroyed() {
   NotifyTabHelperWillClose();
 }
 
 void ConstrainedWindowViews::OnNativeConstrainedWindowMouseActivate() {
   Activate();
 }
 
 views::internal::NativeWidgetDelegate*
     ConstrainedWindowViews::AsNativeWidgetDelegate() {
   return this;
 }
 
 int ConstrainedWindowViews::GetNonClientComponent(const gfx::Point& point) {
   // Prevent a constrained window to be moved by the user.
   return HTNOWHERE;
 }
 
-void ConstrainedWindowViews::PositionChromeStyleWindow() {
-  DCHECK(enable_chrome_style_);
-  gfx::Rect bounds = GetRootView()->bounds();
-  ConstrainedWindowTabHelperDelegate* tab_helper_delegate =
-      ConstrainedWindowTabHelper::FromWebContents(web_contents_)->delegate();
-
-  BrowserWindow* browser_window =
-      tab_helper_delegate ? tab_helper_delegate->GetBrowserWindow() : NULL;
-  int top_y;
-  if (browser_window && browser_window->GetConstrainedWindowTopY(&top_y)) {
-    bounds.set_y(top_y);
-    bounds.set_x(
-        browser_window->GetBounds().width() / 2 - bounds.width() / 2);
-    SetBounds(bounds);
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// ConstrainedWindowViews, content::WebContentsObserver implementation:
-
 void ConstrainedWindowViews::WebContentsDestroyed(
     content::WebContents* web_contents) {
   web_contents_ = NULL;
 }
+
+void ConstrainedWindowViews::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  DCHECK(enable_chrome_style_);
+  DCHECK_EQ(type, content::NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED);
+  if (*content::Details<bool>(details).ptr())
+    Show();
+  else
+    Hide();
+}
+
+void ConstrainedWindowViews::PositionChromeStyleWindow(const gfx::Size& size) {
+  DCHECK(enable_chrome_style_);
+  gfx::Rect bounds(GetRootView()->bounds().origin(), size);
+  ConstrainedWindowTabHelperDelegate* tab_helper_delegate =
+      ConstrainedWindowTabHelper::FromWebContents(web_contents_)->delegate();
+  BrowserWindow* browser_window =
+      tab_helper_delegate ? tab_helper_delegate->GetBrowserWindow() : NULL;
+  if (browser_window) {
+    bounds.set_x(browser_window->GetBounds().width() / 2 - bounds.width() / 2);
+    int top_y;
+    if (browser_window->GetConstrainedWindowTopY(&top_y))
+      bounds.set_y(top_y);
+  }
+  SetBounds(bounds);
+}