Reland Extension Installed InfoBubble

chrome/browser/views/info_bubble.cc

 // Copyright (c) 2006-2008 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/views/info_bubble.h"
 
 #include "app/gfx/canvas.h"
 #include "app/gfx/color_utils.h"
 #include "app/gfx/path.h"
 #include "base/keyboard_codes.h"
@@ skipping 17 matching lines @@
 
 // This is used to paint the border of the InfoBubble.  Windows uses this via
 // BorderWidget (see below), while others can use it directly in the bubble.
 class BorderContents : public views::View {
  public:
   BorderContents() { }
 
   // Given the size of the contents and the rect to point at, initializes the
   // bubble and returns the bounds of both the border
   // and the contents inside the bubble.
-  // |is_rtl| is true if the UI is RTL and thus the arrow should default to the
-  // right side of the bubble; otherwise it defaults to the left top corner, and
-  // then is moved as necessary to try and fit the whole bubble on the same
-  // monitor as the rect being pointed to.
+  // |prefer_arrow_on_right| specifies the preferred location for the arrow
+  // anchor. If the bubble does not fit on the monitor, the arrow location may
+  // changed so it can.
   //
   // TODO(pkasting): Maybe this should use mirroring transformations instead,
   // which would hopefully simplify this code.
   void InitAndGetBounds(
       const gfx::Rect& position_relative_to,  // In screen coordinates
       const gfx::Size& contents_size,
-      bool is_rtl,
+      bool prefer_arrow_on_right,
       gfx::Rect* contents_bounds,             // Returned in window coordinates
       gfx::Rect* window_bounds);              // Returned in screen coordinates
 
  private:
   virtual ~BorderContents() { }
 
   // Overridden from View:
   virtual void Paint(gfx::Canvas* canvas);
 
   DISALLOW_COPY_AND_ASSIGN(BorderContents);
 };
 
 void BorderContents::InitAndGetBounds(
     const gfx::Rect& position_relative_to,
     const gfx::Size& contents_size,
-    bool is_rtl,
+    bool prefer_arrow_on_right,
     gfx::Rect* contents_bounds,
     gfx::Rect* window_bounds) {
   // Margins between the contents and the inside of the border, in pixels.
   const int kLeftMargin = 6;
   const int kTopMargin = 6;
   const int kRightMargin = 6;
   const int kBottomMargin = 9;
 
   // Set the border.
   BubbleBorder* bubble_border = new BubbleBorder;
   set_border(bubble_border);
   bubble_border->set_background_color(InfoBubble::kBackgroundColor);
 
   // Give the contents a margin.
   gfx::Size local_contents_size(contents_size);
   local_contents_size.Enlarge(kLeftMargin + kRightMargin,
                               kTopMargin + kBottomMargin);
 
-  // Try putting the arrow in its default location, and calculating the bounds.
-  BubbleBorder::ArrowLocation arrow_location(is_rtl ?
+  // Try putting the arrow in its initial location, and calculating the
+  // bounds.
+  BubbleBorder::ArrowLocation arrow_location(prefer_arrow_on_right ?
       BubbleBorder::TOP_RIGHT : BubbleBorder::TOP_LEFT);
   bubble_border->set_arrow_location(arrow_location);
   *window_bounds =
       bubble_border->GetBounds(position_relative_to, local_contents_size);
 
   // See if those bounds will fit on the monitor.
   scoped_ptr<WindowSizer::MonitorInfoProvider> monitor_provider(
       WindowSizer::CreateDefaultMonitorInfoProvider());
   gfx::Rect monitor_bounds(
       monitor_provider->GetMonitorWorkAreaMatching(position_relative_to));
   if (!monitor_bounds.IsEmpty() && !monitor_bounds.Contains(*window_bounds)) {
     // The bounds don't fit.  Move the arrow to try and improve things.
-    bool arrow_on_left =
-        (is_rtl ? (window_bounds->x() < monitor_bounds.x()) :
-                  (window_bounds->right() <= monitor_bounds.right()));
+    bool arrow_on_left = prefer_arrow_on_right ?
+        (window_bounds->x() < monitor_bounds.x()) :
+        (window_bounds->right() <= monitor_bounds.right());
     if (window_bounds->bottom() > monitor_bounds.bottom()) {
       arrow_location = arrow_on_left ?
           BubbleBorder::BOTTOM_LEFT : BubbleBorder::BOTTOM_RIGHT;
     } else {
       arrow_location = arrow_on_left ?
           BubbleBorder::TOP_LEFT : BubbleBorder::TOP_RIGHT;
     }
     bubble_border->set_arrow_location(arrow_location);
 
     // Now get the recalculated bounds.
@@ skipping 38 matching lines @@
 BorderWidget::BorderWidget() {
   set_delete_on_destroy(false);  // Our owner will free us manually.
   set_window_style(WS_POPUP);
   set_window_ex_style(WS_EX_TOOLWINDOW | WS_EX_LAYERED);
 }
 
 gfx::Rect BorderWidget::InitAndGetBounds(
     HWND owner,
     const gfx::Rect& position_relative_to,
     const gfx::Size& contents_size,
-    bool is_rtl) {
+    bool prefer_arrow_on_right) {
   // Set up the border view and ask it to calculate our bounds (and our
   // contents').
   BorderContents* border_contents = new BorderContents;
   gfx::Rect contents_bounds, window_bounds;
-  border_contents->InitAndGetBounds(position_relative_to, contents_size, is_rtl,
-                                    &contents_bounds, &window_bounds);
+  border_contents->InitAndGetBounds(position_relative_to, contents_size,
+                                    prefer_arrow_on_right, &contents_bounds,
+                                    &window_bounds);
 
   // Initialize ourselves.
   WidgetWin::Init(GetAncestor(owner, GA_ROOT), window_bounds);
   SetContentsView(border_contents);
   SetWindowPos(owner, 0, 0, 0, 0,
                SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOREDRAW);
 
   // Chop a hole out of our region to show the contents through.
   // CreateRectRgn() expects (left, top, right, bottom) in window coordinates.
   HRGN contents_region = CreateRectRgn(contents_bounds.x(), contents_bounds.y(),
@@ skipping 65 matching lines @@
   // Create a View to hold the contents of the main window.
   views::View* contents_view = new views::View;
   // Adding |contents| as a child has to be done before we call
   // contents->GetPreferredSize() below, since some supplied views don't
   // actually initialize themselves until they're added to a hierarchy.
   contents_view->AddChildView(contents);
   SetContentsView(contents_view);
 
   // Calculate and set the bounds for all windows and views.
   gfx::Rect window_bounds;
+
+  bool prefer_arrow_on_right =
+      (contents->UILayoutIsRightToLeft() == delegate->PreferOriginSideAnchor());
+
 #if defined(OS_WIN)
   border_.reset(new BorderWidget);
   // Initialize and position the border window.
   window_bounds = border_->InitAndGetBounds(GetNativeView(),
       position_relative_to, contents->GetPreferredSize(),
-      contents->UILayoutIsRightToLeft());
+      prefer_arrow_on_right);
 
   // Make |contents| take up the entire contents view.
   contents_view->SetLayoutManager(new views::FillLayout);
 
   // Paint the background color behind the contents.
   contents_view->set_background(
       views::Background::CreateSolidBackground(kBackgroundColor));
 #else
   // Create a view to paint the border and background.
   BorderContents* border_contents = new BorderContents;
   gfx::Rect contents_bounds;
   border_contents->InitAndGetBounds(position_relative_to,
-      contents->GetPreferredSize(), contents->UILayoutIsRightToLeft(),
+      contents->GetPreferredSize(), prefer_arrow_on_right,
       &contents_bounds, &window_bounds);
   // This new view must be added before |contents| so it will paint under it.
   contents_view->AddChildView(0, border_contents);
 
   // |contents_view| has no layout manager, so we have to explicitly position
   // its children.
   border_contents->SetBounds(gfx::Rect(gfx::Point(), window_bounds.size()));
   contents->SetBounds(contents_bounds);
 #endif
   SetBounds(window_bounds);
@@ skipping 48 matching lines @@
 #endif
 }
 
 bool InfoBubble::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!delegate_ || delegate_->CloseOnEscape()) {
     Close(true);
     return true;
   }
   return false;
 }