src/chrome/browser/ui/gtk/extensions/extension_popup_gtk.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/gtk/extensions/extension_popup_gtk.h"
   6
   7 #include <gtk/gtk.h>
   8
   9 #include <algorithm>
  10
  11 #include "base/bind.h"
  12 #include "base/bind_helpers.h"
  13 #include "base/callback.h"
  14 #include "base/i18n/rtl.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "chrome/browser/chrome_notification_types.h"
  17 #include "chrome/browser/devtools/devtools_window.h"
  18 #include "chrome/browser/extensions/extension_host.h"
  19 #include "chrome/browser/extensions/extension_process_manager.h"
  20 #include "chrome/browser/extensions/extension_system.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/ui/browser.h"
  23 #include "chrome/browser/ui/browser_window.h"
  24 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
  25 #include "content/public/browser/devtools_agent_host.h"
  26 #include "content/public/browser/devtools_manager.h"
  27 #include "content/public/browser/notification_details.h"
  28 #include "content/public/browser/notification_source.h"
  29 #include "content/public/browser/render_view_host.h"
  30 #include "content/public/browser/render_widget_host_view.h"
  31 #include "url/gurl.h"
  32
  33 using content::RenderViewHost;
  34
  35 ExtensionPopupGtk* ExtensionPopupGtk::current_extension_popup_ = NULL;
  36
  37 // The minimum/maximum dimensions of the extension popup.
  38 // The minimum is just a little larger than the size of a browser action button.
  39 // The maximum is an arbitrary number that should be smaller than most screens.
  40 const int ExtensionPopupGtk::kMinWidth = 25;
  41 const int ExtensionPopupGtk::kMinHeight = 25;
  42 const int ExtensionPopupGtk::kMaxWidth = 800;
  43 const int ExtensionPopupGtk::kMaxHeight = 600;
  44
  45 ExtensionPopupGtk::ExtensionPopupGtk(Browser* browser,
  46                                      extensions::ExtensionHost* host,
  47                                      GtkWidget* anchor,
  48                                      ShowAction show_action)
  49     : browser_(browser),
  50       bubble_(NULL),
  51       host_(host),
  52       anchor_(anchor),
  53       devtools_callback_(base::Bind(
  54           &ExtensionPopupGtk::OnDevToolsStateChanged, base::Unretained(this))),
  55       weak_factory_(this) {
  56   host_->view()->SetContainer(this);
  57   being_inspected_ = show_action == SHOW_AND_INSPECT;
  58
  59   // If the host had somehow finished loading, then we'd miss the notification
  60   // and not show.  This seems to happen in single-process mode.
  61   if (host->did_stop_loading()) {
  62     ShowPopup();
  63   } else {
  64     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
  65                    content::Source<Profile>(host->profile()));
  66   }
  67
  68   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
  69                  content::Source<Profile>(host->profile()));
  70   content::DevToolsManager::GetInstance()->AddAgentStateCallback(
  71       devtools_callback_);
  72 }
  73
  74 ExtensionPopupGtk::~ExtensionPopupGtk() {
  75   content::DevToolsManager::GetInstance()->RemoveAgentStateCallback(
  76       devtools_callback_);
  77 }
  78
  79 // static
  80 void ExtensionPopupGtk::Show(const GURL& url, Browser* browser,
  81     GtkWidget* anchor, ShowAction show_action) {
  82   ExtensionProcessManager* manager =
  83       extensions::ExtensionSystem::Get(browser->profile())->process_manager();
  84   DCHECK(manager);
  85   if (!manager)
  86     return;
  87
  88   extensions::ExtensionHost* host = manager->CreatePopupHost(url, browser);
  89   // This object will delete itself when the bubble is closed.
  90   new ExtensionPopupGtk(browser, host, anchor, show_action);
  91 }
  92
  93 void ExtensionPopupGtk::Observe(int type,
  94                                 const content::NotificationSource& source,
  95                                 const content::NotificationDetails& details) {
  96   switch (type) {
  97     case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING:
  98       if (content::Details<extensions::ExtensionHost>(host_.get()) == details)
  99         ShowPopup();
 100       break;
 101     case chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE:
 102       if (content::Details<extensions::ExtensionHost>(host_.get()) == details)
 103         DestroyPopup();
 104       break;
 105     default:
 106       NOTREACHED() << "Received unexpected notification";
 107   }
 108 }
 109
 110 void ExtensionPopupGtk::OnDevToolsStateChanged(
 111     content::DevToolsAgentHost* agent_host, bool attached) {
 112   // Make sure it's the devtools window that is inspecting our popup.
 113   if (host_->render_view_host() != agent_host->GetRenderViewHost())
 114     return;
 115   if (attached) {
 116     // Make sure that the popup won't go away when the inspector is activated.
 117     if (bubble_)
 118       bubble_->StopGrabbingInput();
 119
 120     being_inspected_ = true;
 121   } else {
 122     // If the devtools window is closing, we post a task to ourselves to
 123     // close the popup. This gives the devtools window a chance to finish
 124     // detaching from the inspected RenderViewHost.
 125     base::MessageLoop::current()->PostTask(
 126         FROM_HERE,
 127         base::Bind(&ExtensionPopupGtk::DestroyPopupWithoutResult,
 128                    weak_factory_.GetWeakPtr()));
 129   }
 130 }
 131
 132 void ExtensionPopupGtk::BubbleClosing(BubbleGtk* bubble,
 133                                       bool closed_by_escape) {
 134   current_extension_popup_ = NULL;
 135   delete this;
 136 }
 137
 138 void ExtensionPopupGtk::OnExtensionSizeChanged(
 139     ExtensionViewGtk* view,
 140     const gfx::Size& new_size) {
 141   int width = std::max(kMinWidth, std::min(kMaxWidth, new_size.width()));
 142   int height = std::max(kMinHeight, std::min(kMaxHeight, new_size.height()));
 143
 144   view->render_view_host()->GetView()->SetSize(gfx::Size(width, height));
 145   gtk_widget_set_size_request(view->native_view(), width, height);
 146 }
 147
 148 bool ExtensionPopupGtk::DestroyPopup() {
 149   if (!bubble_) {
 150     NOTREACHED();
 151     return false;
 152   }
 153
 154   bubble_->Close();
 155   return true;
 156 }
 157
 158 void ExtensionPopupGtk::ShowPopup() {
 159   if (bubble_) {
 160     NOTREACHED();
 161     return;
 162   }
 163
 164   if (being_inspected_)
 165     DevToolsWindow::OpenDevToolsWindow(host_->render_view_host());
 166
 167   // Only one instance should be showing at a time. Get rid of the old one, if
 168   // any. Typically, |current_extension_popup_| will be NULL, but it can be
 169   // non-NULL if a browser action button is clicked while another extension
 170   // popup's extension host is still loading.
 171   if (current_extension_popup_)
 172     current_extension_popup_->DestroyPopup();
 173   current_extension_popup_ = this;
 174
 175   GtkWidget* border_box = gtk_alignment_new(0, 0, 1.0, 1.0);
 176   // This border is necessary so the bubble's corners do not get cut off by the
 177   // render view.
 178   gtk_container_set_border_width(GTK_CONTAINER(border_box), 2);
 179   gtk_container_add(GTK_CONTAINER(border_box), host_->view()->native_view());
 180
 181   // We'll be in the upper-right corner of the window for LTR languages, so we
 182   // want to put the arrow at the upper-right corner of the bubble to match the
 183   // page and app menus.
 184   bubble_ = BubbleGtk::Show(anchor_,
 185                             NULL,
 186                             border_box,
 187                             BubbleGtk::ANCHOR_TOP_RIGHT,
 188                             being_inspected_ ? 0 :
 189                                 BubbleGtk::POPUP_WINDOW | BubbleGtk::GRAB_INPUT,
 190                             GtkThemeService::GetFrom(browser_->profile()),
 191                             this);
 192 }
 193
 194 void ExtensionPopupGtk::DestroyPopupWithoutResult() {
 195   DestroyPopup();
 196 }
 197
 198 gfx::Rect ExtensionPopupGtk::GetViewBounds() {
 199   GtkAllocation allocation;
 200   gtk_widget_get_allocation(host_->view()->native_view(), &allocation);
 201   return gfx::Rect(allocation);
 202 }