Create interface "EventPageTracker" for checking an extension's

extensions/browser/process_manager.cc

 // Copyright 2013 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 "extensions/browser/process_manager.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
+#include "extensions/browser/lazy_background_task_queue.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/browser/process_manager_delegate.h"
 #include "extensions/browser/process_manager_factory.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/browser/view_type_utils.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/manifest_handlers/background_info.h"
 #include "extensions/common/manifest_handlers/incognito_info.h"
@@ skipping 64 matching lines @@
 };
 
 static void CreateBackgroundHostForExtensionLoad(
     ProcessManager* manager, const Extension* extension) {
   DVLOG(1) << "CreateBackgroundHostForExtensionLoad";
   if (BackgroundInfo::HasPersistentBackgroundPage(extension))
     manager->CreateBackgroundHost(extension,
                                   BackgroundInfo::GetBackgroundURL(extension));
 }
 
+void OnExtensionLoad(const base::Callback<void(bool)>& callback,
+                     extensions::ExtensionHost* host) {
+  callback.Run(host != nullptr);
+}
+
 }  // namespace
 
 struct ProcessManager::BackgroundPageData {
   // The count of things keeping the lazy background page alive.
   int lazy_keepalive_count;
 
   // Tracks if an impulse event has occured since the last polling check.
   bool keepalive_impulse;
   bool previous_keepalive_impulse;
 
@@ skipping 279 matching lines @@
 
 ExtensionHost* ProcessManager::GetBackgroundHostForExtension(
     const std::string& extension_id) {
   for (ExtensionHost* host : background_hosts_) {
     if (host->extension_id() == extension_id)
       return host;
   }
   return nullptr;
 }
 
+void ProcessManager::WakeExtension(const std::string& extension_id,
+                                   const base::Callback<void(bool)>& callback) {
+  if (GetBackgroundHostForExtension(extension_id)) {
+    // Run the callback immediately if the extension is already awake.
+    callback.Run(true);

[not at google - send to devlin, 2015/04/24 20:05:08]

Re-entrant callbacks lead to insidious bugs. Either post to the current message
loop, or signal to caller via a bool return value if already active (and don't
call the callback in that case).

[Kevin Marshall, 2015/04/24 21:04:53]

Good point, using return value. Updated docs.

+  }
+  LazyBackgroundTaskQueue* queue =
+      ExtensionSystem::Get(browser_context_)->lazy_background_task_queue();
+  queue->AddPendingTask(browser_context_, extension_id,
+                        base::Bind(&OnExtensionLoad, callback));

[not at google - send to devlin, 2015/04/24 20:05:08]

Is there a better / more descriptive name than just "OnExtensionLoad"?

[Kevin Marshall, 2015/04/24 21:04:53]

How's this? "PropagateExtensionWakeResult"

+}
+
 bool ProcessManager::IsBackgroundHostClosing(const std::string& extension_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   return (host && background_page_data_[extension_id].is_closing);
 }
 
 const Extension* ProcessManager::GetExtensionForRenderFrameHost(
     content::RenderFrameHost* render_frame_host) {
   return extension_registry_->enabled_extensions().GetByID(
       GetExtensionID(render_frame_host));
 }
@@ skipping 496 matching lines @@
   if (extension && !IncognitoInfo::IsSplitMode(extension)) {
     BrowserContext* original_context =
         ExtensionsBrowserClient::Get()->GetOriginalContext(browser_context());
     return ProcessManager::Get(original_context)->GetSiteInstanceForURL(url);
   }
 
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions