[Extensions Toolbar] Move some popup logic to be platform-agnostic

chrome/browser/ui/extensions/extension_action_view_controller.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/extensions/extension_action_view_controller.h"
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/commands/command_service.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/extension_action.h"
+#include "chrome/browser/extensions/extension_view_host.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/extensions/accelerator_priority.h"
 #include "chrome/browser/ui/extensions/extension_action_platform_delegate.h"
 #include "chrome/browser/ui/toolbar/toolbar_action_view_delegate.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
+#include "content/public/browser/notification_details.h"
+#include "content/public/browser/notification_source.h"
+#include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
+#include "extensions/browser/notification_types.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 
 using extensions::ActionInfo;
 using extensions::CommandService;
 
 ExtensionActionViewController::ExtensionActionViewController(
     const extensions::Extension* extension,
     Browser* browser,
     ExtensionAction* extension_action)
     : extension_(extension),
       browser_(browser),
       extension_action_(extension_action),
+      popup_host_(nullptr),
       view_delegate_(nullptr),
       platform_delegate_(ExtensionActionPlatformDelegate::Create(this)),
       icon_factory_(browser->profile(), extension, extension_action, this),
       icon_observer_(nullptr),
       extension_registry_(
           extensions::ExtensionRegistry::Get(browser_->profile())) {
   DCHECK(extension_action);
   DCHECK(extension_action->action_type() == ActionInfo::TYPE_PAGE ||
          extension_action->action_type() == ActionInfo::TYPE_BROWSER);
   DCHECK(extension);
 }
 
 ExtensionActionViewController::~ExtensionActionViewController() {
 }
 
 const std::string& ExtensionActionViewController::GetId() const {
   return extension_->id();
 }
 
 void ExtensionActionViewController::SetDelegate(
     ToolbarActionViewDelegate* delegate) {
   DCHECK((delegate == nullptr) ^ (view_delegate_ == nullptr));
   if (delegate) {
     view_delegate_ = delegate;
     platform_delegate_->OnDelegateSet();
   } else {
+    if (is_showing_popup())
+      HidePopup();
     platform_delegate_.reset();
     view_delegate_ = nullptr;
   }
 }
 
 gfx::Image ExtensionActionViewController::GetIcon(
     content::WebContents* web_contents) {
   if (!ExtensionIsValid())
     return gfx::Image();
 
@@ skipping 55 matching lines @@
 bool ExtensionActionViewController::HasPopup(
     content::WebContents* web_contents) const {
   if (!ExtensionIsValid())
     return false;
 
   int tab_id = SessionTabHelper::IdForTab(web_contents);
   return (tab_id < 0) ? false : extension_action_->HasPopup(tab_id);
 }
 
 void ExtensionActionViewController::HidePopup() {
-  if (platform_delegate_->IsShowingPopup())
+  if (is_showing_popup()) {
     platform_delegate_->CloseOwnPopup();
+    // We need to do these actions synchronously (instead of closing and then
+    // performing the rest of the cleanup in Observe()) because the extension
+    // host can close asynchronously, and we need to keep the view delegate
+    // up-to-date.
+    OnPopupClosed();
+  }
 }
 
 gfx::NativeView ExtensionActionViewController::GetPopupNativeView() {
   return platform_delegate_->GetPopupNativeView();
 }
 
 ui::MenuModel* ExtensionActionViewController::GetContextMenu() {
   if (!ExtensionIsValid() || !extension()->ShowConfigureContextMenus())
     return nullptr;
 
@@ skipping 63 matching lines @@
   ExecuteAction(SHOW_POPUP_AND_INSPECT, true);
 }
 
 void ExtensionActionViewController::OnIconUpdated() {
   if (icon_observer_)
     icon_observer_->OnIconUpdated();
   if (view_delegate_)
     view_delegate_->UpdateState();
 }
 
+void ExtensionActionViewController::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  // TODO(devlin): Ew. Notifications. Extract out an observer interface for

[Avi (use Gerrit), 2015/01/29 02:59:26]

Ew! That's the spirit!

+  // ExtensionHost and convert this.
+  DCHECK_EQ(extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED, type);
+  extensions::ExtensionHost* host =
+      content::Details<extensions::ExtensionHost>(details).ptr();
+  if (host == popup_host_)
+    OnPopupClosed();
+}
+
 bool ExtensionActionViewController::ExtensionIsValid() const {
   return extension_registry_->enabled_extensions().Contains(extension_->id());
 }
 
 bool ExtensionActionViewController::GetExtensionCommand(
     extensions::Command* command) {
   DCHECK(command);
   if (!ExtensionIsValid())
     return false;
 
   CommandService* command_service = CommandService::Get(browser_->profile());
   if (extension_action_->action_type() == ActionInfo::TYPE_PAGE) {
     return command_service->GetPageActionCommand(
         extension_->id(), CommandService::ACTIVE, command, NULL);
   }
   return command_service->GetBrowserActionCommand(
       extension_->id(), CommandService::ACTIVE, command, NULL);
 }
 
 bool ExtensionActionViewController::ShowPopupWithUrl(
     PopupShowAction show_action,
     const GURL& popup_url,
     bool grant_tab_permissions) {
   if (!ExtensionIsValid())
     return false;
 
-  bool already_showing = platform_delegate_->IsShowingPopup();
+  bool already_showing = is_showing_popup();
 
   // Always hide the current popup, even if it's not owned by this extension.
   // Only one popup should be visible at a time.
   platform_delegate_->CloseActivePopup();
 
   // If we were showing a popup already, then we treat the action to open the
   // same one as a desire to close it (like clicking a menu button that was
   // already open).
   if (already_showing)
     return false;
 
-  return platform_delegate_->ShowPopupWithUrl(
+  popup_host_ = platform_delegate_->ShowPopupWithUrl(
       show_action, popup_url, grant_tab_permissions);
+  if (popup_host_) {
+    // Lazily register for notifications about extension host destructions.
+    static const int kType = extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED;
+    content::Source<content::BrowserContext> source(browser_->profile());
+    if (!registrar_.IsRegistered(this, kType, source))
+      registrar_.Add(this, kType, source);
+
+    view_delegate_->OnPopupShown(grant_tab_permissions);
+  }
+  return is_showing_popup();
 }
+
+void ExtensionActionViewController::OnPopupClosed() {
+  popup_host_ = nullptr;
+  view_delegate_->OnPopupClosed();
+}