Revert 162252 - 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,
-    ChromeStyleClientInsets chrome_style_client_insets)
+    bool enable_chrome_style)
     : WebContentsObserver(web_contents),
       web_contents_(web_contents),
-      enable_chrome_style_(enable_chrome_style),
-      chrome_style_client_insets_(chrome_style_client_insets),
       ALLOW_THIS_IN_INITIALIZER_LIST(native_constrained_window_(
-          NativeConstrainedWindow::CreateNativeConstrainedWindow(this))) {
+          NativeConstrainedWindow::CreateNativeConstrainedWindow(this))),
+      enable_chrome_style_(enable_chrome_style) {
   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(GetRootView()->bounds().size());
-    registrar_.Add(this,
-                   content::NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
-                   content::Source<content::WebContents>(web_contents));
+    PositionChromeStyleWindow();
   }
 
   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(size);
-  else
-    Widget::CenterWindow(size);
+    PositionChromeStyleWindow();
 }
 
 views::NonClientFrameView* ConstrainedWindowViews::CreateNonClientFrameView() {
-  if (enable_chrome_style_)
-    return new ConstrainedWindowFrameSimple(this, chrome_style_client_insets_);
+  if (enable_chrome_style_) {
+    return new ConstrainedWindowFrameSimple(this);
+  } else {
 #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:
+
 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);
-}