<webview>: Implement WebRequest API

chrome/browser/extensions/event_router.cc

 // Copyright (c) 2012 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/extensions/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 146 matching lines @@
 void EventRouter::DispatchEvent(IPC::Sender* ipc_sender,
                                 void* profile_id,
                                 const std::string& extension_id,
                                 const std::string& event_name,
                                 scoped_ptr<ListValue> event_args,
                                 const GURL& event_url,
                                 UserGestureState user_gesture,
                                 const EventFilteringInfo& info) {
   DispatchExtensionMessage(ipc_sender, profile_id, extension_id, event_name,
                            event_args.get(), event_url, user_gesture, info);
+
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&EventRouter::IncrementInFlightEventsOnUI,
+                  profile_id,
+                  extension_id));
 }
 
 EventRouter::EventRouter(Profile* profile, ExtensionPrefs* extension_prefs)
     : profile_(profile),
       listeners_(this),
       activity_log_(ActivityLog::GetInstance(profile)),
       dispatch_chrome_updated_event_(false) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
@@ skipping 367 matching lines @@
 
     queue->AddPendingTask(profile, extension->id(),
                           base::Bind(&EventRouter::DispatchPendingEvent,
                                      base::Unretained(this), dispatched_event));
     return true;
   }
 
   return false;
 }
 
+// static
+void EventRouter::IncrementInFlightEventsOnUI(
+    void* profile_id,
+    const std::string& extension_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  Profile* profile = reinterpret_cast<Profile*>(profile_id);
+  extensions::EventRouter* event_router =
+      extensions::ExtensionSystem::Get(profile)->event_router();
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  const Extension* extension =
+      extension_service->extensions()->GetByID(extension_id);
+  if (!extension)
+    return;
+  event_router->IncrementInFlightEvents(profile, extension);
+}
+
 void EventRouter::IncrementInFlightEvents(Profile* profile,
                                           const Extension* extension) {
   // Only increment in-flight events if the lazy background page is active,
   // because that's the only time we'll get an ACK.
   if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
     ExtensionProcessManager* pm =
         ExtensionSystem::Get(profile)->process_manager();
     ExtensionHost* host = pm->GetBackgroundHostForExtension(extension->id());
     if (host)
       pm->IncrementLazyKeepaliveCount(extension);
@@ skipping 155 matching lines @@
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions