Initial support for inspecting extension popups.

chrome/browser/views/browser_actions_container.cc

 // Copyright (c) 2010 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/browser_actions_container.h"
 
 #include "app/gfx/canvas.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
+#include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/detachable_toolbar_view.h"
 #include "chrome/browser/views/extensions/browser_action_drag_data.h"
 #include "chrome/browser/views/extensions/extension_popup.h"
@@ skipping 100 matching lines @@
 BrowserActionButton::~BrowserActionButton() {
   if (tracker_)
     tracker_->StopTrackingImageLoad();
 }
 
 gfx::Insets BrowserActionButton::GetInsets() const {
   static gfx::Insets zero_inset;
   return zero_inset;
 }
 
-void BrowserActionButton::ButtonPressed(
-    views::Button* sender, const views::Event& event) {
-  panel_->OnBrowserActionExecuted(this);
+void BrowserActionButton::ButtonPressed(views::Button* sender,
+    const views::Event& event) {
+  panel_->OnBrowserActionExecuted(this, false);  // inspect_with_devtools
 }
 
 void BrowserActionButton::OnImageLoaded(SkBitmap* image, size_t index) {
   if (image)
     default_icon_ = *image;
 
   tracker_ = NULL;  // The tracker object will delete itself when we return.
 
   // Call back to UpdateState() because a more specific icon might have been set
   // while the load was outstanding.
@@ skipping 42 matching lines @@
   if (tab_id < 0) {
     NOTREACHED() << "Button is not on a specific tab.";
     GURL empty_url;
     return empty_url;
   }
   return browser_action_->GetPopupUrl(tab_id);
 }
 
 bool BrowserActionButton::Activate() {
   if (IsPopup()) {
-    panel_->OnBrowserActionExecuted(this);
+    panel_->OnBrowserActionExecuted(this, false); // inspect_with_devtools
 
     // TODO(erikkay): Run a nested modal loop while the mouse is down to
     // enable menu-like drag-select behavior.
 
     // The return value of this method is returned via OnMousePressed.
     // We need to return false here since we're handing off focus to another
     // widget/view, and true will grab it right back and try to send events
     // to us.
     return false;
   }
   return true;
 }
 
 bool BrowserActionButton::OnMousePressed(const views::MouseEvent& e) {
   showing_context_menu_ = e.IsRightMouseButton();
   if (showing_context_menu_) {
     SetButtonPushed();
 
     // Get the top left point of this button in screen coordinates.
     gfx::Point point = gfx::Point(0, 0);
     ConvertPointToScreen(this, &point);
 
     // Make the menu appear below the button.
     point.Offset(0, height());
 
-    panel_->GetContextMenu()->Run(extension(), point);
+    panel_->GetContextMenu()->Run(extension(), extension()->browser_action(),
+        panel_, panel_->profile()->GetPrefs(), point);
 
     SetButtonNotPushed();
     return false;
   } else if (IsPopup()) {
     return MenuButton::OnMousePressed(e);
   }
   return TextButton::OnMousePressed(e);
 }
 
 void BrowserActionButton::OnMouseReleased(const views::MouseEvent& e,
@@ skipping 95 matching lines @@
       animation_target_size_(0),
       drop_indicator_position_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(show_menu_task_factory_(this)) {
   SetID(VIEW_ID_BROWSER_ACTION_TOOLBAR);
 
   ExtensionsService* extension_service = profile_->GetExtensionsService();
   if (!extension_service)  // The |extension_service| can be NULL in Incognito.
     return;
 
-  registrar_.Add(this, NotificationType::EXTENSION_HOST_VIEW_SHOULD_CLOSE,
-                 Source<Profile>(profile_));
-
   model_ = extension_service->toolbar_model();
   model_->AddObserver(this);
 
   resize_animation_.reset(new SlideAnimation(this));
   resize_gripper_ = new views::ResizeGripper(this);
   resize_gripper_->SetVisible(false);
   AddChildView(resize_gripper_);
 
   // TODO(glen): Come up with a new bitmap for the chevron.
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
@@ skipping 121 matching lines @@
 }
 
 void BrowserActionsContainer::OnBrowserActionVisibilityChanged() {
   resize_gripper_->SetVisible(browser_action_views_.size() > 0);
 
   owner_view_->Layout();
   owner_view_->SchedulePaint();
 }
 
 void BrowserActionsContainer::HidePopup() {
-  if (popup_) {
-    // This sometimes gets called via a timer (See BubbleLostFocus), so clear
-    // the task factory in case one is pending.
-    task_factory_.RevokeAll();
-
-    // Save these variables in local temporaries since destroying the popup
-    // calls BubbleLostFocus to be called, which will try to call HidePopup()
-    // again if popup_ is non-null.
-    ExtensionPopup* closing_popup = popup_;
-    BrowserActionButton* closing_button = popup_button_;
-    popup_ = NULL;
-    popup_button_ = NULL;
-
-    closing_popup->DetachFromBrowser();
-    delete closing_popup;
-    closing_button->SetButtonNotPushed();
-    return;
-  }
+  if (popup_)
+    popup_->Close();
 }
 
 void BrowserActionsContainer::TestExecuteBrowserAction(int index) {
   BrowserActionButton* button = browser_action_views_[index]->button();
-  OnBrowserActionExecuted(button);
+  OnBrowserActionExecuted(button, false); // inspect_with_devtools
 }
 
 void BrowserActionsContainer::TestSetIconVisibilityCount(size_t icons) {
   chevron_->SetVisible(icons < browser_action_views_.size());
   container_size_.set_width(IconCountToWidth(icons));
   Layout();
   SchedulePaint();
 }
 
 void BrowserActionsContainer::OnBrowserActionExecuted(
-    BrowserActionButton* button) {
+    BrowserActionButton* button, bool inspect_with_devtools) {
   ExtensionAction* browser_action = button->browser_action();
 
   // Popups just display.  No notification to the extension.
   // TODO(erikkay): should there be?
   if (button->IsPopup()) {
     // If we're showing the same popup, just hide it and return.
     bool same_showing = popup_ && button == popup_button_;
 
     // Always hide the current popup, even if it's not the same.
     // Only one popup should be visible at a time.
@@ skipping 10 matching lines @@
     View::ConvertPointToScreen(reference_view, &origin);
     gfx::Rect rect = reference_view->bounds();
     rect.set_x(origin.x());
     rect.set_y(origin.y());
 
     gfx::NativeWindow frame_window =
         browser_->window()->GetNativeHandle();
     BubbleBorder::ArrowLocation arrow_location = UILayoutIsRightToLeft() ?
         BubbleBorder::TOP_LEFT : BubbleBorder::TOP_RIGHT;
 
-    popup_ = ExtensionPopup::Show(
-        button->GetPopupUrl(),
-        browser_,
-        browser_->profile(),
-        frame_window,
-        rect,
-        arrow_location,
+    popup_ = ExtensionPopup::Show(button->GetPopupUrl(), browser_,
+        browser_->profile(), frame_window, rect, arrow_location,
         true,  // Activate the popup window.
-        ExtensionPopup::BUBBLE_CHROME);
-    popup_->set_delegate(this);
+        inspect_with_devtools,
+        ExtensionPopup::BUBBLE_CHROME,
+        this);  // ExtensionPopupDelegate
     popup_button_ = button;
     popup_button_->SetButtonPushed();
+
     return;
   }
 
   // Otherwise, we send the action to the extension.
   ExtensionBrowserEventRouter::GetInstance()->BrowserActionExecuted(
       profile_, browser_action->extension_id(), browser_);
 }
 
 gfx::Size BrowserActionsContainer::GetPreferredSize() {
   if (browser_action_views_.empty())
@@ skipping 229 matching lines @@
 }
 
 void BrowserActionsContainer::MoveBrowserAction(
     const std::string& extension_id, size_t new_index) {
   ExtensionsService* service = profile_->GetExtensionsService();
   Extension* extension = service->GetExtensionById(extension_id, false);
   model_->MoveBrowserAction(extension, new_index);
   SchedulePaint();
 }
 
-void BrowserActionsContainer::Observe(NotificationType type,
-                                      const NotificationSource& source,
-                                      const NotificationDetails& details) {
-  switch (type.value) {
-    case NotificationType::EXTENSION_HOST_VIEW_SHOULD_CLOSE:
-      // If we aren't the host of the popup, then disregard the notification.
-      if (!popup_ || Details<ExtensionHost>(popup_->host()) != details)
-        return;
-
-      HidePopup();
-      break;
-
-    default:
-      NOTREACHED() << "Unexpected notification";
-  }
-}
-
-void BrowserActionsContainer::BubbleBrowserWindowMoved(BrowserBubble* bubble) {
-}
-
-void BrowserActionsContainer::BubbleBrowserWindowClosing(
-    BrowserBubble* bubble) {
-  HidePopup();
-}
-
-void BrowserActionsContainer::BubbleGotFocus(BrowserBubble* bubble) {
-  if (!popup_)
-    return;
-
-  // Forward the focus to the renderer.
-  popup_->host()->render_view_host()->view()->Focus();
-}
-
-void BrowserActionsContainer::BubbleLostFocus(BrowserBubble* bubble,
-                                              bool lost_focus_to_child) {
-  // Don't close when we are losing focus to a child window, this is the case
-  // for select popups and alert for example.
-  if (!popup_ || lost_focus_to_child)
-    return;
-
-  // This is a bit annoying.  If you click on the button that generated the
-  // current popup, then we first get this lost focus message, and then
-  // we get the click action.  This results in the popup being immediately
-  // shown again.  To workaround this, we put in a delay.
-  MessageLoop::current()->PostTask(FROM_HERE,
-      task_factory_.NewRunnableMethod(&BrowserActionsContainer::HidePopup));
-}
-
 void BrowserActionsContainer::RunMenu(View* source, const gfx::Point& pt) {
   if (source == chevron_) {
     overflow_menu_ = new BrowserActionOverflowMenuController(
         this, chevron_, browser_action_views_, VisibleBrowserActions());
     overflow_menu_->set_observer(this);
     overflow_menu_->RunMenu(GetWindow()->GetNativeWindow(), false);
   }
 }
 
 void BrowserActionsContainer::WriteDragData(View* sender,
@@ skipping 265 matching lines @@
   profile_->GetPrefs()->SetInteger(prefs::kBrowserActionContainerWidth,
                                    container_size_.width());
 }
 
 void BrowserActionsContainer::NotifyMenuDeleted(
     BrowserActionOverflowMenuController* controller) {
   DCHECK(controller == overflow_menu_);
   overflow_menu_ = NULL;
 }
 
+void BrowserActionsContainer::ShowPopupForDevToolsWindow(Extension* extension,
+    ExtensionAction* extension_action) {
+  OnBrowserActionExecuted(GetBrowserActionView(extension)->button(),
+      true); // inspect_with_devtools
+}
+
+void BrowserActionsContainer::ExtensionPopupClosed(ExtensionPopup* popup) {
+  // ExtensionPopup is ref-counted, so we don't need to delete it.
+  DCHECK_EQ(popup_, popup);
+  popup_ = NULL;
+  popup_button_->SetButtonNotPushed();
+  popup_button_ = NULL;
+}
+
 bool BrowserActionsContainer::ShouldDisplayBrowserAction(Extension* extension) {
   // Only display incognito-enabled extensions while in incognito mode.
   return (!profile_->IsOffTheRecord() ||
           profile_->GetExtensionsService()->IsIncognitoEnabled(extension));
 }