Update permission bubble anchor when omnibar is hidden

chrome/browser/ui/views/website_settings/permissions_bubble_view.cc

 // Copyright 2014 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/website_settings/permissions_bubble_view.h"
 
+#include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/views/exclusive_access_bubble_views.h"
+#include "chrome/browser/ui/views/frame/browser_view.h"
+#include "chrome/browser/ui/views/frame/top_container_view.h"
+#include "chrome/browser/ui/views/location_bar/location_bar_view.h"
+#include "chrome/browser/ui/views/location_bar/location_icon_view.h"
 #include "chrome/browser/ui/views/website_settings/permission_selector_view.h"
 #include "chrome/browser/ui/views/website_settings/permission_selector_view_observer.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_request.h"
+#include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/combobox_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/views/bubble/bubble_delegate.h"
+#include "ui/views/bubble/bubble_frame_view.h"
 #include "ui/views/controls/button/checkbox.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/controls/button/label_button_border.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/button/menu_button_listener.h"
 #include "ui/views/controls/combobox/combobox.h"
 #include "ui/views/controls/combobox/combobox_listener.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/controls/menu/menu_runner.h"
 #include "ui/views/layout/box_layout.h"
@@ skipping 52 matching lines @@
   int index_;
   Listener* listener_;
   scoped_ptr<PermissionMenuModel> model_;
   scoped_ptr<views::MenuRunner> menu_runner_;
 };
 
 PermissionCombobox::PermissionCombobox(Listener* listener,
                                        int index,
                                        const GURL& url,
                                        ContentSetting setting)
-    : MenuButton(NULL, base::string16(), this, true),
+    : MenuButton(nullptr, base::string16(), this, true),
       index_(index),
       listener_(listener),
       model_(new PermissionMenuModel(
           url,
           setting,
           base::Bind(&PermissionCombobox::PermissionChanged,
                      base::Unretained(this)))) {
   SetText(model_->GetLabelAt(model_->GetIndexOfCommandId(setting)));
   SizeToPreferredSize();
 }
@@ skipping 31 matching lines @@
       index_, permission.setting == CONTENT_SETTING_ALLOW);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // View implementation for the permissions bubble.
 class PermissionsBubbleDelegateView : public views::BubbleDelegateView,
                                       public views::ButtonListener,
                                       public PermissionCombobox::Listener {
  public:
   PermissionsBubbleDelegateView(
-      views::View* anchor,
+      views::View* anchor_view,
+      views::BubbleBorder::Arrow anchor_arrow,
       PermissionBubbleViewViews* owner,
       const std::string& languages,
       const std::vector<PermissionBubbleRequest*>& requests,
       const std::vector<bool>& accept_state);
   ~PermissionsBubbleDelegateView() override;
 
   void Close();
   void SizeToContents();
 
   // BubbleDelegateView:
   bool ShouldShowCloseButton() const override;
   bool ShouldShowWindowTitle() const override;
   const gfx::FontList& GetTitleFontList() const override;
   base::string16 GetWindowTitle() const override;
   void OnWidgetDestroying(views::Widget* widget) override;
 
   // ButtonListener:
   void ButtonPressed(views::Button* button, const ui::Event& event) override;
 
   // PermissionCombobox::Listener:
   void PermissionSelectionChanged(int index, bool allowed) override;
 
+  // Updates the anchor's arrow and view. Also repositions the bubble so it's
+  // displayed in the correct location.
+  void UpdateAnchor(views::View* anchor_view,
+                    views::BubbleBorder::Arrow anchor_arrow);
+
  private:
   PermissionBubbleViewViews* owner_;
   views::Button* allow_;
   views::Button* deny_;
   views::Combobox* allow_combobox_;
   base::string16 hostname_;
   scoped_ptr<PermissionMenuModel> menu_button_model_;
   std::vector<PermissionCombobox*> customize_comboboxes_;
 
   DISALLOW_COPY_AND_ASSIGN(PermissionsBubbleDelegateView);
 };
 
 PermissionsBubbleDelegateView::PermissionsBubbleDelegateView(
-    views::View* anchor,
+    views::View* anchor_view,
+    views::BubbleBorder::Arrow anchor_arrow,
     PermissionBubbleViewViews* owner,
     const std::string& languages,
     const std::vector<PermissionBubbleRequest*>& requests,
     const std::vector<bool>& accept_state)
-    : views::BubbleDelegateView(anchor, views::BubbleBorder::TOP_LEFT),
+    : views::BubbleDelegateView(anchor_view, anchor_arrow),
       owner_(owner),
-      allow_(NULL),
-      deny_(NULL),
-      allow_combobox_(NULL) {
+      allow_(nullptr),
+      deny_(nullptr),
+      allow_combobox_(nullptr) {
   DCHECK(!requests.empty());
 
   RemoveAllChildViews(true);
   customize_comboboxes_.clear();
   set_close_on_esc(true);
   set_close_on_deactivate(false);
 
   SetLayoutManager(new views::BoxLayout(
       views::BoxLayout::kVertical, kBubbleOuterMargin, 0, kItemMajorSpacing));
 
   hostname_ = net::FormatUrl(requests[0]->GetRequestingHostname(),
                              languages,
                              net::kFormatUrlOmitUsernamePassword |
                              net::kFormatUrlOmitTrailingSlashOnBareHostname,
-                             net::UnescapeRule::SPACES, NULL, NULL, NULL);
+                             net::UnescapeRule::SPACES,
+                             nullptr, nullptr, nullptr);
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   for (size_t index = 0; index < requests.size(); index++) {
     DCHECK(index < accept_state.size());
     // The row is laid out containing a leading-aligned label area and a
     // trailing column which will be filled if there are multiple permission
     // requests.
     views::View* row = new views::View();
     views::GridLayout* row_layout = new views::GridLayout(row);
     row->SetLayoutManager(row_layout);
@@ skipping 78 matching lines @@
 
   button_layout->AddPaddingRow(0, kBubbleOuterMargin);
 }
 
 PermissionsBubbleDelegateView::~PermissionsBubbleDelegateView() {
   if (owner_)
     owner_->Closing();
 }
 
 void PermissionsBubbleDelegateView::Close() {
-  owner_ = NULL;
+  owner_ = nullptr;
   GetWidget()->Close();
 }
 
 bool PermissionsBubbleDelegateView::ShouldShowCloseButton() const {
   return true;
 }
 
 bool PermissionsBubbleDelegateView::ShouldShowWindowTitle() const {
   return true;
 }
 
 const gfx::FontList& PermissionsBubbleDelegateView::GetTitleFontList() const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   return rb.GetFontList(ui::ResourceBundle::BaseFont);
 }
 
 base::string16 PermissionsBubbleDelegateView::GetWindowTitle() const {
   return l10n_util::GetStringFUTF16(IDS_PERMISSIONS_BUBBLE_PROMPT,
                                     hostname_);
 }
 
 void PermissionsBubbleDelegateView::SizeToContents() {
   BubbleDelegateView::SizeToContents();
 }
 
 void PermissionsBubbleDelegateView::OnWidgetDestroying(views::Widget* widget) {
   views::BubbleDelegateView::OnWidgetDestroying(widget);
   if (owner_) {
     owner_->Closing();
-    owner_ = NULL;
+    owner_ = nullptr;
   }
 }
 
 void PermissionsBubbleDelegateView::ButtonPressed(views::Button* button,
                                                   const ui::Event& event) {
   if (!owner_)
     return;
 
   if (button == allow_)
     owner_->Accept();
   else if (button == deny_)
     owner_->Deny();
 }
 
 void PermissionsBubbleDelegateView::PermissionSelectionChanged(
     int index, bool allowed) {
   owner_->Toggle(index, allowed);
 }
 
+void PermissionsBubbleDelegateView::UpdateAnchor(
+    views::View* anchor_view,
+    views::BubbleBorder::Arrow anchor_arrow) {
+  if (GetAnchorView() == anchor_view && arrow() == anchor_arrow)
+    return;
+
+  set_arrow(anchor_arrow);
+
+  // Update the border in the bubble: will either add or remove the arrow.
+  views::BubbleFrameView* frame =
+      views::BubbleDelegateView::GetBubbleFrameView();
+  views::BubbleBorder::Arrow adjusted_arrow = anchor_arrow;
+  if (base::i18n::IsRTL())
+    adjusted_arrow = views::BubbleBorder::horizontal_mirror(adjusted_arrow);
+  frame->SetBubbleBorder(scoped_ptr<views::BubbleBorder>(
+      new views::BubbleBorder(adjusted_arrow, shadow(), color())));
+
+  // Reposition the bubble based on the updated arrow and view.
+  SetAnchorView(anchor_view);
+}
+
 //////////////////////////////////////////////////////////////////////////////
 // PermissionBubbleViewViews
 
-PermissionBubbleViewViews::PermissionBubbleViewViews(
-    views::View* anchor_view,
-    const std::string& languages)
-    : anchor_view_(anchor_view),
-      delegate_(NULL),
-      bubble_delegate_(NULL),
-      languages_(languages) {}
+PermissionBubbleViewViews::PermissionBubbleViewViews(Browser* browser)
+    : browser_(browser),
+      delegate_(nullptr),
+      bubble_delegate_(nullptr) {}
 
 PermissionBubbleViewViews::~PermissionBubbleViewViews() {
   if (delegate_)
-    delegate_->SetView(NULL);
+    delegate_->SetView(nullptr);
+}
+
+views::View* PermissionBubbleViewViews::GetAnchorView() {
+  BrowserView* browser_view = BrowserView::GetBrowserViewForBrowser(browser_);
+
+  if (browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR))
+    return browser_view->GetLocationBarView()->location_icon_view();
+
+  if (browser_view->IsFullscreenBubbleVisible())
+    return browser_view->exclusive_access_bubble()->GetView();
+
+  return browser_view->top_container();
+}
+
+views::BubbleBorder::Arrow PermissionBubbleViewViews::GetAnchorArrow() {
+  if (browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR))
+    return views::BubbleBorder::TOP_LEFT;
+  return views::BubbleBorder::NONE;
+}
+
+void PermissionBubbleViewViews::UpdateAnchorPosition() {
+  if (IsVisible())
+    bubble_delegate_->UpdateAnchor(GetAnchorView(), GetAnchorArrow());
 }
 
 void PermissionBubbleViewViews::SetDelegate(Delegate* delegate) {
   delegate_ = delegate;
 }
 
 void PermissionBubbleViewViews::Show(
     const std::vector<PermissionBubbleRequest*>& requests,
     const std::vector<bool>& values) {
-  if (bubble_delegate_ != NULL)
+  if (bubble_delegate_)
     bubble_delegate_->Close();
 
   bubble_delegate_ =
-      new PermissionsBubbleDelegateView(anchor_view_, this, languages_,
-                                        requests, values);
+      new PermissionsBubbleDelegateView(
+          GetAnchorView(), GetAnchorArrow(), this,
+          browser_->profile()->GetPrefs()->GetString(prefs::kAcceptLanguages),
+          requests, values);
+
+  // Set |parent_window| because some valid anchors can become hidden.
+  bubble_delegate_->set_parent_window(browser_->window()->GetNativeWindow());
+
   views::BubbleDelegateView::CreateBubble(bubble_delegate_)->Show();
   bubble_delegate_->SizeToContents();
 }
 
 bool PermissionBubbleViewViews::CanAcceptRequestUpdate() {
   return !(bubble_delegate_ && bubble_delegate_->IsMouseHovered());
 }
 
 void PermissionBubbleViewViews::Hide() {
   if (bubble_delegate_) {
     bubble_delegate_->Close();
-    bubble_delegate_ = NULL;
+    bubble_delegate_ = nullptr;
   }
 }
 
 bool PermissionBubbleViewViews::IsVisible() {
-  return bubble_delegate_ != NULL;
+  return bubble_delegate_ != nullptr;
 }
 
 void PermissionBubbleViewViews::Closing() {
   if (bubble_delegate_)
-    bubble_delegate_ = NULL;
+    bubble_delegate_ = nullptr;
   if (delegate_)
     delegate_->Closing();
 }
 
 void PermissionBubbleViewViews::Toggle(int index, bool value) {
   if (delegate_)
     delegate_->ToggleAccept(index, value);
 }
 
 void PermissionBubbleViewViews::Accept() {
   if (delegate_)
     delegate_->Accept();
 }
 
 void PermissionBubbleViewViews::Deny() {
   if (delegate_)
     delegate_->Deny();
 }