Home | History | Annotate | Download | only in extension_action 
      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/extensions/api/extension_action/extension_action_api.h"
      6 
      7 #include "base/lazy_instance.h"
      8 #include "base/strings/string_number_conversions.h"
      9 #include "base/values.h"
     10 #include "chrome/browser/extensions/active_script_controller.h"
     11 #include "chrome/browser/extensions/extension_action_manager.h"
     12 #include "chrome/browser/extensions/extension_tab_util.h"
     13 #include "chrome/browser/extensions/extension_toolbar_model.h"
     14 #include "chrome/browser/extensions/tab_helper.h"
     15 #include "chrome/browser/profiles/profile.h"
     16 #include "chrome/browser/sessions/session_tab_helper.h"
     17 #include "chrome/browser/ui/browser.h"
     18 #include "chrome/browser/ui/browser_finder.h"
     19 #include "chrome/browser/ui/browser_window.h"
     20 #include "chrome/browser/ui/location_bar/location_bar.h"
     21 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     22 #include "chrome/common/extensions/api/extension_action/action_info.h"
     23 #include "chrome/common/render_messages.h"
     24 #include "content/public/browser/notification_service.h"
     25 #include "extensions/browser/event_router.h"
     26 #include "extensions/browser/extension_function_registry.h"
     27 #include "extensions/browser/extension_host.h"
     28 #include "extensions/browser/extension_registry.h"
     29 #include "extensions/browser/image_util.h"
     30 #include "extensions/browser/notification_types.h"
     31 #include "extensions/common/error_utils.h"
     32 #include "extensions/common/feature_switch.h"
     33 #include "ui/gfx/image/image.h"
     34 #include "ui/gfx/image/image_skia.h"
     35 
     36 using content::WebContents;
     37 
     38 namespace extensions {
     39 
     40 namespace {
     41 
     42 // Whether the browser action is visible in the toolbar.
     43 const char kBrowserActionVisible[] = "browser_action_visible";
     44 
     45 // Errors.
     46 const char kNoExtensionActionError[] =
     47     "This extension has no action specified.";
     48 const char kNoTabError[] = "No tab with id: *.";
     49 const char kOpenPopupError[] =
     50     "Failed to show popup either because there is an existing popup or another "
     51     "error occurred.";
     52 
     53 }  // namespace
     54 
     55 //
     56 // ExtensionActionAPI::Observer
     57 //
     58 
     59 void ExtensionActionAPI::Observer::OnExtensionActionUpdated(
     60     ExtensionAction* extension_action,
     61     content::WebContents* web_contents,
     62     content::BrowserContext* browser_context) {
     63 }
     64 
     65 void ExtensionActionAPI::Observer::OnPageActionsUpdated(
     66     content::WebContents* web_contents) {
     67 }
     68 
     69 void ExtensionActionAPI::Observer::OnExtensionActionAPIShuttingDown() {
     70 }
     71 
     72 ExtensionActionAPI::Observer::~Observer() {
     73 }
     74 
     75 //
     76 // ExtensionActionAPI
     77 //
     78 
     79 static base::LazyInstance<BrowserContextKeyedAPIFactory<ExtensionActionAPI> >
     80     g_factory = LAZY_INSTANCE_INITIALIZER;
     81 
     82 ExtensionActionAPI::ExtensionActionAPI(content::BrowserContext* context)
     83     : browser_context_(context) {
     84   ExtensionFunctionRegistry* registry =
     85       ExtensionFunctionRegistry::GetInstance();
     86 
     87   // Browser Actions
     88   registry->RegisterFunction<BrowserActionSetIconFunction>();
     89   registry->RegisterFunction<BrowserActionSetTitleFunction>();
     90   registry->RegisterFunction<BrowserActionSetBadgeTextFunction>();
     91   registry->RegisterFunction<BrowserActionSetBadgeBackgroundColorFunction>();
     92   registry->RegisterFunction<BrowserActionSetPopupFunction>();
     93   registry->RegisterFunction<BrowserActionGetTitleFunction>();
     94   registry->RegisterFunction<BrowserActionGetBadgeTextFunction>();
     95   registry->RegisterFunction<BrowserActionGetBadgeBackgroundColorFunction>();
     96   registry->RegisterFunction<BrowserActionGetPopupFunction>();
     97   registry->RegisterFunction<BrowserActionEnableFunction>();
     98   registry->RegisterFunction<BrowserActionDisableFunction>();
     99   registry->RegisterFunction<BrowserActionOpenPopupFunction>();
    100 
    101   // Page Actions
    102   registry->RegisterFunction<PageActionShowFunction>();
    103   registry->RegisterFunction<PageActionHideFunction>();
    104   registry->RegisterFunction<PageActionSetIconFunction>();
    105   registry->RegisterFunction<PageActionSetTitleFunction>();
    106   registry->RegisterFunction<PageActionSetPopupFunction>();
    107   registry->RegisterFunction<PageActionGetTitleFunction>();
    108   registry->RegisterFunction<PageActionGetPopupFunction>();
    109 }
    110 
    111 ExtensionActionAPI::~ExtensionActionAPI() {
    112 }
    113 
    114 // static
    115 BrowserContextKeyedAPIFactory<ExtensionActionAPI>*
    116 ExtensionActionAPI::GetFactoryInstance() {
    117   return g_factory.Pointer();
    118 }
    119 
    120 // static
    121 ExtensionActionAPI* ExtensionActionAPI::Get(content::BrowserContext* context) {
    122   return BrowserContextKeyedAPIFactory<ExtensionActionAPI>::Get(context);
    123 }
    124 
    125 // static
    126 bool ExtensionActionAPI::GetBrowserActionVisibility(
    127     const ExtensionPrefs* prefs,
    128     const std::string& extension_id) {
    129   bool visible = false;
    130   if (!prefs || !prefs->ReadPrefAsBoolean(extension_id,
    131                                           kBrowserActionVisible,
    132                                           &visible)) {
    133     return true;
    134   }
    135   return visible;
    136 }
    137 
    138 // static
    139 void ExtensionActionAPI::SetBrowserActionVisibility(
    140     ExtensionPrefs* prefs,
    141     const std::string& extension_id,
    142     bool visible) {
    143   if (GetBrowserActionVisibility(prefs, extension_id) == visible)
    144     return;
    145 
    146   prefs->UpdateExtensionPref(extension_id,
    147                              kBrowserActionVisible,
    148                              new base::FundamentalValue(visible));
    149   content::NotificationService::current()->Notify(
    150       NOTIFICATION_EXTENSION_BROWSER_ACTION_VISIBILITY_CHANGED,
    151       content::Source<ExtensionPrefs>(prefs),
    152       content::Details<const std::string>(&extension_id));
    153 }
    154 
    155 void ExtensionActionAPI::AddObserver(Observer* observer) {
    156   observers_.AddObserver(observer);
    157 }
    158 
    159 void ExtensionActionAPI::RemoveObserver(Observer* observer) {
    160   observers_.RemoveObserver(observer);
    161 }
    162 
    163 ExtensionAction::ShowAction ExtensionActionAPI::ExecuteExtensionAction(
    164     const Extension* extension,
    165     Browser* browser,
    166     bool grant_active_tab_permissions) {
    167   content::WebContents* web_contents =
    168       browser->tab_strip_model()->GetActiveWebContents();
    169   if (!web_contents)
    170     return ExtensionAction::ACTION_NONE;
    171 
    172   int tab_id = SessionTabHelper::IdForTab(web_contents);
    173 
    174   ActiveScriptController* active_script_controller =
    175       ActiveScriptController::GetForWebContents(web_contents);
    176   bool has_pending_scripts = false;
    177   if (active_script_controller &&
    178       active_script_controller->WantsToRun(extension)) {
    179     has_pending_scripts = true;
    180   }
    181 
    182   // Grant active tab if appropriate.
    183   if (grant_active_tab_permissions) {
    184     TabHelper::FromWebContents(web_contents)->active_tab_permission_granter()->
    185         GrantIfRequested(extension);
    186   }
    187 
    188   // If this was a request to run a script, it will have been run once active
    189   // tab was granted. Return without executing the action, since we should only
    190   // run pending scripts OR the extension action, not both.
    191   if (has_pending_scripts)
    192     return ExtensionAction::ACTION_NONE;
    193 
    194   ExtensionAction* extension_action =
    195       ExtensionActionManager::Get(browser_context_)->GetExtensionAction(
    196           *extension);
    197 
    198   // Anything that gets here should have a page or browser action.
    199   DCHECK(extension_action);
    200   if (!extension_action->GetIsVisible(tab_id))
    201     return ExtensionAction::ACTION_NONE;
    202 
    203   if (extension_action->HasPopup(tab_id))
    204     return ExtensionAction::ACTION_SHOW_POPUP;
    205 
    206   ExtensionActionExecuted(*extension_action, web_contents);
    207   return ExtensionAction::ACTION_NONE;
    208 }
    209 
    210 bool ExtensionActionAPI::ShowExtensionActionPopup(
    211     const Extension* extension,
    212     Browser* browser,
    213     bool grant_active_tab_permissions) {
    214   ExtensionAction* extension_action =
    215       ExtensionActionManager::Get(browser_context_)->GetExtensionAction(
    216           *extension);
    217   if (!extension_action)
    218     return false;
    219 
    220   if (extension_action->action_type() == ActionInfo::TYPE_PAGE &&
    221       !FeatureSwitch::extension_action_redesign()->IsEnabled()) {
    222     // We show page actions in the location bar unless the new toolbar is
    223     // enabled.
    224     return browser->window()->GetLocationBar()->ShowPageActionPopup(
    225         extension, grant_active_tab_permissions);
    226   } else {
    227     return ExtensionToolbarModel::Get(browser->profile())->
    228         ShowExtensionActionPopup(
    229             extension, browser, grant_active_tab_permissions);
    230   }
    231 }
    232 
    233 void ExtensionActionAPI::NotifyChange(ExtensionAction* extension_action,
    234                                       content::WebContents* web_contents,
    235                                       content::BrowserContext* context) {
    236   FOR_EACH_OBSERVER(
    237       Observer,
    238       observers_,
    239       OnExtensionActionUpdated(extension_action, web_contents, context));
    240 
    241   if (extension_action->action_type() == ActionInfo::TYPE_PAGE)
    242     NotifyPageActionsChanged(web_contents);
    243 }
    244 
    245 void ExtensionActionAPI::ClearAllValuesForTab(
    246     content::WebContents* web_contents) {
    247   DCHECK(web_contents);
    248   int tab_id = SessionTabHelper::IdForTab(web_contents);
    249   content::BrowserContext* browser_context = web_contents->GetBrowserContext();
    250   const ExtensionSet& enabled_extensions =
    251       ExtensionRegistry::Get(browser_context_)->enabled_extensions();
    252   ExtensionActionManager* action_manager =
    253       ExtensionActionManager::Get(browser_context_);
    254 
    255   for (ExtensionSet::const_iterator iter = enabled_extensions.begin();
    256        iter != enabled_extensions.end(); ++iter) {
    257     ExtensionAction* extension_action =
    258         action_manager->GetBrowserAction(*iter->get());
    259     if (!extension_action)
    260       extension_action = action_manager->GetPageAction(*iter->get());
    261     if (extension_action) {
    262       extension_action->ClearAllValuesForTab(tab_id);
    263       NotifyChange(extension_action, web_contents, browser_context);
    264     }
    265   }
    266 }
    267 
    268 void ExtensionActionAPI::DispatchEventToExtension(
    269     content::BrowserContext* context,
    270     const std::string& extension_id,
    271     const std::string& event_name,
    272     scoped_ptr<base::ListValue> event_args) {
    273   if (!EventRouter::Get(context))
    274     return;
    275 
    276   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
    277   event->restrict_to_browser_context = context;
    278   event->user_gesture = EventRouter::USER_GESTURE_ENABLED;
    279   EventRouter::Get(context)
    280       ->DispatchEventToExtension(extension_id, event.Pass());
    281 }
    282 
    283 void ExtensionActionAPI::ExtensionActionExecuted(
    284     const ExtensionAction& extension_action,
    285     WebContents* web_contents) {
    286   const char* event_name = NULL;
    287   switch (extension_action.action_type()) {
    288     case ActionInfo::TYPE_BROWSER:
    289       event_name = "browserAction.onClicked";
    290       break;
    291     case ActionInfo::TYPE_PAGE:
    292       event_name = "pageAction.onClicked";
    293       break;
    294     case ActionInfo::TYPE_SYSTEM_INDICATOR:
    295       // The System Indicator handles its own clicks.
    296       break;
    297   }
    298 
    299   if (event_name) {
    300     scoped_ptr<base::ListValue> args(new base::ListValue());
    301     base::DictionaryValue* tab_value =
    302         ExtensionTabUtil::CreateTabValue(web_contents);
    303     args->Append(tab_value);
    304 
    305     DispatchEventToExtension(
    306         web_contents->GetBrowserContext(),
    307         extension_action.extension_id(),
    308         event_name,
    309         args.Pass());
    310   }
    311 }
    312 
    313 void ExtensionActionAPI::NotifyPageActionsChanged(
    314     content::WebContents* web_contents) {
    315   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
    316   if (!browser)
    317     return;
    318   LocationBar* location_bar =
    319       browser->window() ? browser->window()->GetLocationBar() : NULL;
    320   if (!location_bar)
    321     return;
    322   location_bar->UpdatePageActions();
    323 
    324   FOR_EACH_OBSERVER(Observer, observers_, OnPageActionsUpdated(web_contents));
    325 }
    326 
    327 void ExtensionActionAPI::Shutdown() {
    328   FOR_EACH_OBSERVER(Observer, observers_, OnExtensionActionAPIShuttingDown());
    329 }
    330 
    331 //
    332 // ExtensionActionFunction
    333 //
    334 
    335 ExtensionActionFunction::ExtensionActionFunction()
    336     : details_(NULL),
    337       tab_id_(ExtensionAction::kDefaultTabId),
    338       contents_(NULL),
    339       extension_action_(NULL) {
    340 }
    341 
    342 ExtensionActionFunction::~ExtensionActionFunction() {
    343 }
    344 
    345 bool ExtensionActionFunction::RunSync() {
    346   ExtensionActionManager* manager = ExtensionActionManager::Get(GetProfile());
    347   if (StartsWithASCII(name(), "systemIndicator.", false)) {
    348     extension_action_ = manager->GetSystemIndicator(*extension());
    349   } else {
    350     extension_action_ = manager->GetBrowserAction(*extension());
    351     if (!extension_action_) {
    352       extension_action_ = manager->GetPageAction(*extension());
    353     }
    354   }
    355   if (!extension_action_) {
    356     // TODO(kalman): ideally the browserAction/pageAction APIs wouldn't event
    357     // exist for extensions that don't have one declared. This should come as
    358     // part of the Feature system.
    359     error_ = kNoExtensionActionError;
    360     return false;
    361   }
    362 
    363   // Populates the tab_id_ and details_ members.
    364   EXTENSION_FUNCTION_VALIDATE(ExtractDataFromArguments());
    365 
    366   // Find the WebContents that contains this tab id if one is required.
    367   if (tab_id_ != ExtensionAction::kDefaultTabId) {
    368     ExtensionTabUtil::GetTabById(tab_id_,
    369                                  GetProfile(),
    370                                  include_incognito(),
    371                                  NULL,
    372                                  NULL,
    373                                  &contents_,
    374                                  NULL);
    375     if (!contents_) {
    376       error_ = ErrorUtils::FormatErrorMessage(
    377           kNoTabError, base::IntToString(tab_id_));
    378       return false;
    379     }
    380   } else {
    381     // Only browser actions and system indicators have a default tabId.
    382     ActionInfo::Type action_type = extension_action_->action_type();
    383     EXTENSION_FUNCTION_VALIDATE(
    384         action_type == ActionInfo::TYPE_BROWSER ||
    385         action_type == ActionInfo::TYPE_SYSTEM_INDICATOR);
    386   }
    387   return RunExtensionAction();
    388 }
    389 
    390 bool ExtensionActionFunction::ExtractDataFromArguments() {
    391   // There may or may not be details (depends on the function).
    392   // The tabId might appear in details (if it exists), as the first
    393   // argument besides the action type (depends on the function), or be omitted
    394   // entirely.
    395   base::Value* first_arg = NULL;
    396   if (!args_->Get(0, &first_arg))
    397     return true;
    398 
    399   switch (first_arg->GetType()) {
    400     case base::Value::TYPE_INTEGER:
    401       CHECK(first_arg->GetAsInteger(&tab_id_));
    402       break;
    403 
    404     case base::Value::TYPE_DICTIONARY: {
    405       // Found the details argument.
    406       details_ = static_cast<base::DictionaryValue*>(first_arg);
    407       // Still need to check for the tabId within details.
    408       base::Value* tab_id_value = NULL;
    409       if (details_->Get("tabId", &tab_id_value)) {
    410         switch (tab_id_value->GetType()) {
    411           case base::Value::TYPE_NULL:
    412             // OK; tabId is optional, leave it default.
    413             return true;
    414           case base::Value::TYPE_INTEGER:
    415             CHECK(tab_id_value->GetAsInteger(&tab_id_));
    416             return true;
    417           default:
    418             // Boom.
    419             return false;
    420         }
    421       }
    422       // Not found; tabId is optional, leave it default.
    423       break;
    424     }
    425 
    426     case base::Value::TYPE_NULL:
    427       // The tabId might be an optional argument.
    428       break;
    429 
    430     default:
    431       return false;
    432   }
    433 
    434   return true;
    435 }
    436 
    437 void ExtensionActionFunction::NotifyChange() {
    438   ExtensionActionAPI::Get(GetProfile())->NotifyChange(
    439       extension_action_, contents_, GetProfile());
    440 }
    441 
    442 bool ExtensionActionFunction::SetVisible(bool visible) {
    443   if (extension_action_->GetIsVisible(tab_id_) == visible)
    444     return true;
    445   extension_action_->SetIsVisible(tab_id_, visible);
    446   NotifyChange();
    447   return true;
    448 }
    449 
    450 bool ExtensionActionShowFunction::RunExtensionAction() {
    451   return SetVisible(true);
    452 }
    453 
    454 bool ExtensionActionHideFunction::RunExtensionAction() {
    455   return SetVisible(false);
    456 }
    457 
    458 bool ExtensionActionSetIconFunction::RunExtensionAction() {
    459   EXTENSION_FUNCTION_VALIDATE(details_);
    460 
    461   // setIcon can take a variant argument: either a dictionary of canvas
    462   // ImageData, or an icon index.
    463   base::DictionaryValue* canvas_set = NULL;
    464   int icon_index;
    465   if (details_->GetDictionary("imageData", &canvas_set)) {
    466     gfx::ImageSkia icon;
    467 
    468     EXTENSION_FUNCTION_VALIDATE(
    469         ExtensionAction::ParseIconFromCanvasDictionary(*canvas_set, &icon));
    470 
    471     extension_action_->SetIcon(tab_id_, gfx::Image(icon));
    472   } else if (details_->GetInteger("iconIndex", &icon_index)) {
    473     // Obsolete argument: ignore it.
    474     return true;
    475   } else {
    476     EXTENSION_FUNCTION_VALIDATE(false);
    477   }
    478   NotifyChange();
    479   return true;
    480 }
    481 
    482 bool ExtensionActionSetTitleFunction::RunExtensionAction() {
    483   EXTENSION_FUNCTION_VALIDATE(details_);
    484   std::string title;
    485   EXTENSION_FUNCTION_VALIDATE(details_->GetString("title", &title));
    486   extension_action_->SetTitle(tab_id_, title);
    487   NotifyChange();
    488   return true;
    489 }
    490 
    491 bool ExtensionActionSetPopupFunction::RunExtensionAction() {
    492   EXTENSION_FUNCTION_VALIDATE(details_);
    493   std::string popup_string;
    494   EXTENSION_FUNCTION_VALIDATE(details_->GetString("popup", &popup_string));
    495 
    496   GURL popup_url;
    497   if (!popup_string.empty())
    498     popup_url = extension()->GetResourceURL(popup_string);
    499 
    500   extension_action_->SetPopupUrl(tab_id_, popup_url);
    501   NotifyChange();
    502   return true;
    503 }
    504 
    505 bool ExtensionActionSetBadgeTextFunction::RunExtensionAction() {
    506   EXTENSION_FUNCTION_VALIDATE(details_);
    507   std::string badge_text;
    508   EXTENSION_FUNCTION_VALIDATE(details_->GetString("text", &badge_text));
    509   extension_action_->SetBadgeText(tab_id_, badge_text);
    510   NotifyChange();
    511   return true;
    512 }
    513 
    514 bool ExtensionActionSetBadgeBackgroundColorFunction::RunExtensionAction() {
    515   EXTENSION_FUNCTION_VALIDATE(details_);
    516   base::Value* color_value = NULL;
    517   EXTENSION_FUNCTION_VALIDATE(details_->Get("color", &color_value));
    518   SkColor color = 0;
    519   if (color_value->IsType(base::Value::TYPE_LIST)) {
    520     base::ListValue* list = NULL;
    521     EXTENSION_FUNCTION_VALIDATE(details_->GetList("color", &list));
    522     EXTENSION_FUNCTION_VALIDATE(list->GetSize() == 4);
    523 
    524     int color_array[4] = {0};
    525     for (size_t i = 0; i < arraysize(color_array); ++i) {
    526       EXTENSION_FUNCTION_VALIDATE(list->GetInteger(i, &color_array[i]));
    527     }
    528 
    529     color = SkColorSetARGB(color_array[3], color_array[0],
    530                            color_array[1], color_array[2]);
    531   } else if (color_value->IsType(base::Value::TYPE_STRING)) {
    532     std::string color_string;
    533     EXTENSION_FUNCTION_VALIDATE(details_->GetString("color", &color_string));
    534     if (!image_util::ParseCSSColorString(color_string, &color))
    535       return false;
    536   }
    537 
    538   extension_action_->SetBadgeBackgroundColor(tab_id_, color);
    539   NotifyChange();
    540   return true;
    541 }
    542 
    543 bool ExtensionActionGetTitleFunction::RunExtensionAction() {
    544   SetResult(new base::StringValue(extension_action_->GetTitle(tab_id_)));
    545   return true;
    546 }
    547 
    548 bool ExtensionActionGetPopupFunction::RunExtensionAction() {
    549   SetResult(
    550       new base::StringValue(extension_action_->GetPopupUrl(tab_id_).spec()));
    551   return true;
    552 }
    553 
    554 bool ExtensionActionGetBadgeTextFunction::RunExtensionAction() {
    555   SetResult(new base::StringValue(extension_action_->GetBadgeText(tab_id_)));
    556   return true;
    557 }
    558 
    559 bool ExtensionActionGetBadgeBackgroundColorFunction::RunExtensionAction() {
    560   base::ListValue* list = new base::ListValue();
    561   SkColor color = extension_action_->GetBadgeBackgroundColor(tab_id_);
    562   list->Append(
    563       new base::FundamentalValue(static_cast<int>(SkColorGetR(color))));
    564   list->Append(
    565       new base::FundamentalValue(static_cast<int>(SkColorGetG(color))));
    566   list->Append(
    567       new base::FundamentalValue(static_cast<int>(SkColorGetB(color))));
    568   list->Append(
    569       new base::FundamentalValue(static_cast<int>(SkColorGetA(color))));
    570   SetResult(list);
    571   return true;
    572 }
    573 
    574 BrowserActionOpenPopupFunction::BrowserActionOpenPopupFunction()
    575     : response_sent_(false) {
    576 }
    577 
    578 bool BrowserActionOpenPopupFunction::RunAsync() {
    579   // We only allow the popup in the active window.
    580   Browser* browser = chrome::FindLastActiveWithProfile(
    581                          GetProfile(), chrome::GetActiveDesktop());
    582 
    583   // If there's no active browser, or the Toolbar isn't visible, abort.
    584   // Otherwise, try to open a popup in the active browser.
    585   // TODO(justinlin): Remove toolbar check when http://crbug.com/308645 is
    586   // fixed.
    587   if (!browser ||
    588       !browser->window()->IsActive() ||
    589       !browser->window()->IsToolbarVisible() ||
    590       !ExtensionActionAPI::Get(GetProfile())->ShowExtensionActionPopup(
    591           extension_.get(), browser, false)) {
    592     error_ = kOpenPopupError;
    593     return false;
    594   }
    595 
    596   registrar_.Add(this,
    597                  NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
    598                  content::Source<Profile>(GetProfile()));
    599 
    600   // Set a timeout for waiting for the notification that the popup is loaded.
    601   // Waiting is required so that the popup view can be retrieved by the custom
    602   // bindings for the response callback. It's also needed to keep this function
    603   // instance around until a notification is observed.
    604   base::MessageLoopForUI::current()->PostDelayedTask(
    605       FROM_HERE,
    606       base::Bind(&BrowserActionOpenPopupFunction::OpenPopupTimedOut, this),
    607       base::TimeDelta::FromSeconds(10));
    608   return true;
    609 }
    610 
    611 void BrowserActionOpenPopupFunction::OpenPopupTimedOut() {
    612   if (response_sent_)
    613     return;
    614 
    615   DVLOG(1) << "chrome.browserAction.openPopup did not show a popup.";
    616   error_ = kOpenPopupError;
    617   SendResponse(false);
    618   response_sent_ = true;
    619 }
    620 
    621 void BrowserActionOpenPopupFunction::Observe(
    622     int type,
    623     const content::NotificationSource& source,
    624     const content::NotificationDetails& details) {
    625   DCHECK_EQ(NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING, type);
    626   if (response_sent_)
    627     return;
    628 
    629   ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
    630   if (host->extension_host_type() != VIEW_TYPE_EXTENSION_POPUP ||
    631       host->extension()->id() != extension_->id())
    632     return;
    633 
    634   SendResponse(true);
    635   response_sent_ = true;
    636   registrar_.RemoveAll();
    637 }
    638 
    639 }  // namespace extensions
    640