Convert tabs, windows, and extension APIs to feature system.

chrome/browser/extensions/extension_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/extension_event_router.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.h"
@@ skipping 101 matching lines @@
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALLED,
                  content::Source<Profile>(profile_));
   // TODO(tessamac): also get notified for background page crash/failure.
 }
 
 ExtensionEventRouter::~ExtensionEventRouter() {}
 
+bool ExtensionEventRouter::IsEventAvailable(
+    const std::string& event_name,
+    const std::string& extension_id,
+    content::RenderProcessHost* render_process,
+    Feature::Context context_type) const {
+  ExtensionService* extension_service = profile_->GetExtensionService();
+  const Extension* extension =
+      extension_service->extensions()->GetByID(extension_id);
+  if (!extension)
+    return false;
+
+  ExtensionAPI* api = ExtensionAPI::GetSharedInstance();
+
+  // If the API has been ported to the feature system, use that.
+  if (api->GetFeature(event_name)) {
+    if (!api->IsAvailable(
+            event_name,
+            extension,
+            static_cast<Feature::Context>(context_type))) {
+      LOG(ERROR) << "Access to extension API '" << event_name << "' denied.";
+      return false;
+    }
+  } else {
+    // Otherwise, fall back to the older system.
+    // TODO(aa): Remove this when all APIs have been ported.
+    if (!extension->HasAPIPermission(event_name)) {
+      LOG(ERROR) << "Extension " << extension->id() << " does not have "
+                 << "permission to event: " << event_name;
+      return false;
+    }
+  }
+
+  // If the API requires a privileged process, ensure it is in one.
+  if (api->IsPrivileged(event_name) &&
+      !extension_service->process_map()->Contains(extension->id(),
+                                                  render_process->GetID())) {
+    LOG(ERROR) << "Extension API called from incorrect process";
+    return false;
+  }
+
+  return true;
+}
+
 void ExtensionEventRouter::AddEventListener(
     const std::string& event_name,
+    const std::string& extension_id,
     content::RenderProcessHost* process,
-    const std::string& extension_id) {
+    Feature::Context context_type) {
+  if (!IsEventAvailable(event_name, extension_id, process, context_type))
+    return;
+
   ListenerProcess listener(process, extension_id);
   DCHECK_EQ(listeners_[event_name].count(listener), 0u) << event_name;
   listeners_[event_name].insert(listener);
 
   if (extension_devtools_manager_.get())
     extension_devtools_manager_->AddEventListener(event_name,
                                                   process->GetID());
 
   // We lazily tell the TaskManager to start updating when listeners to the
   // processes.onUpdated event arrive.
@@ skipping 24 matching lines @@
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(
           &NotifyEventListenerRemovedOnIOThread,
           profile_, listener.extension_id, event_name));
 }
 
 void ExtensionEventRouter::AddLazyEventListener(
     const std::string& event_name,
+    const std::string& extension_id,
+    content::RenderProcessHost* render_process,
+    Feature::Context context_type) {
+  if (!IsEventAvailable(event_name, extension_id, render_process, context_type))
+    AddLazyEventListener(event_name, extension_id);
+}
+
+void ExtensionEventRouter::AddLazyEventListener(
+    const std::string& event_name,
     const std::string& extension_id) {
   ListenerProcess lazy_listener(NULL, extension_id);
   bool is_new = lazy_listeners_[event_name].insert(lazy_listener).second;
   if (is_new) {
     ExtensionPrefs* prefs = profile_->GetExtensionService()->extension_prefs();
     std::set<std::string> events = prefs->GetRegisteredEvents(extension_id);
     bool prefs_is_new = events.insert(event_name).second;
     if (prefs_is_new)
       prefs->SetRegisteredEvents(extension_id, events);
   }
@@ skipping 125 matching lines @@
   const Extension* extension = service->extensions()->GetByID(
       listener.extension_id);
 
   // The extension could have been removed, but we do not unregister it until
   // the extension process is unloaded.
   if (!extension)
     return;
 
   Profile* listener_profile = Profile::FromBrowserContext(
       listener.process->GetBrowserContext());
-  extensions::ProcessMap* process_map =
-      listener_profile->GetExtensionService()->process_map();
-  // If the event is privileged, only send to extension processes. Otherwise,
-  // it's OK to send to normal renderers (e.g., for content scripts).
-  if (ExtensionAPI::GetSharedInstance()->IsPrivileged(event->event_name) &&
-      !process_map->Contains(extension->id(), listener.process->GetID())) {
-    return;
-  }
-
   const std::string* event_args;
   if (!CanDispatchEventToProfile(listener_profile, extension,
                                  event, &event_args))
     return;
 
   DispatchEvent(listener.process, listener.extension_id,
                 event->event_name, *event_args,
                 event->event_url, event->user_gesture);
   IncrementInFlightEvents(listener_profile, extension);
 }
@@ skipping 155 matching lines @@
           profile_, extension);
       break;
     }
 
     // TODO(tessamac): if background page crashed/failed clear queue.
     default:
       NOTREACHED();
       return;
   }
 }