<webview>: Implement WebRequest API

chrome/browser/extensions/api/web_request/web_request_api.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/api/web_request/web_request_api.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 66 matching lines @@
 using extensions::web_navigation_api_helpers::GetFrameId;
 
 namespace helpers = extension_web_request_api_helpers;
 namespace keys = extension_web_request_api_constants;
 namespace web_request = extensions::api::web_request;
 namespace declarative_keys = extensions::declarative_webrequest_constants;
 namespace activitylog = activity_log_web_request_constants;
 
 namespace {
 
+const char kWebRequest[] = "webRequest";
+const char kWebView[] = "webview";
+
 // List of all the webRequest events.
 const char* const kWebRequestEvents[] = {
   keys::kOnBeforeRedirectEvent,
   keys::kOnBeforeRequestEvent,
   keys::kOnBeforeSendHeadersEvent,
   keys::kOnCompletedEvent,
   keys::kOnErrorOccurredEvent,
   keys::kOnSendHeadersEvent,
   keys::kOnAuthRequiredEvent,
   keys::kOnResponseStartedEvent,
@@ skipping 24 matching lines @@
     case ExtensionWebRequestEventRouter::kOnErrorOccurred:
       return keys::kOnErrorOccurred;
     case ExtensionWebRequestEventRouter::kOnCompleted:
       return keys::kOnCompleted;
   }
   NOTREACHED();
   return "Not reached";
 }
 
 bool IsWebRequestEvent(const std::string& event_name) {
+  std::string web_request_event_name(event_name);
+  if (web_request_event_name.find(kWebView) != std::string::npos)
+    web_request_event_name.replace(0, sizeof(kWebView) - 1, kWebRequest);
   return std::find(kWebRequestEvents, ARRAYEND(kWebRequestEvents),
-                   event_name) != ARRAYEND(kWebRequestEvents);
+                   web_request_event_name) != ARRAYEND(kWebRequestEvents);
 }
 
 // Returns whether |request| has been triggered by an extension in
 // |extension_info_map|.
 bool IsRequestFromExtension(const net::URLRequest* request,
                             const ExtensionInfoMap* extension_info_map) {
   // |extension_info_map| is NULL for system-level requests.
   if (!extension_info_map)
     return false;
 
@@ skipping 173 matching lines @@
     headers_value->Append(ToHeaderDictionary(it.name(), it.value()));
   return headers_value;
 }
 
 // Creates a StringValue with the status line of |headers|. If |headers| is
 // NULL, an empty string is returned.  Ownership is passed to the caller.
 StringValue* GetStatusLine(net::HttpResponseHeaders* headers) {
   return new StringValue(headers ? headers->GetStatusLine() : std::string());
 }
 
+void RemoveEventListenerOnUI(
+  void* profile_id,
+  const std::string& event_name,
+  int process_id,
+  const std::string& extension_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  Profile* profile = reinterpret_cast<Profile*>(profile_id);
+  if (!g_browser_process->profile_manager()->IsValidProfile(profile))
+    return;
+
+  extensions::EventRouter* event_router =
+      extensions::ExtensionSystem::Get(profile)->event_router();
+  if (!event_router)
+    return;
+
+  content::RenderProcessHost* process =
+      content::RenderProcessHost::FromID(process_id);
+  if (!process)
+    return;
+
+  event_router->RemoveEventListener(event_name, process, extension_id);
+}
+
 // Sends an event to subscribers of chrome.declarativeWebRequest.onMessage.
 // |extension_id| identifies the extension that sends and receives the event.
 // |event_argument| is passed to the event listener.
 void SendOnMessageEventOnUI(
     void* profile_id,
     const std::string& extension_id,
     scoped_ptr<base::DictionaryValue> event_argument) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Profile* profile = reinterpret_cast<Profile*>(profile_id);
@@ skipping 20 matching lines @@
 // added.
 // NOTE(benjhayden) New APIs should not use this sub_event_name trick! It does
 // not play well with event pages. See downloads.onDeterminingFilename and
 // ExtensionDownloadsEventRouter for an alternative approach.
 struct ExtensionWebRequestEventRouter::EventListener {
   std::string extension_id;
   std::string extension_name;
   std::string sub_event_name;
   RequestFilter filter;
   int extra_info_spec;
-  int target_process_id;
-  int target_route_id;
+  int embedder_process_id;
+  int web_view_instance_id;
   base::WeakPtr<IPC::Sender> ipc_sender;
   mutable std::set<uint64> blocked_requests;
 
   // Comparator to work with std::set.
   bool operator<(const EventListener& that) const {
     if (extension_id < that.extension_id)
       return true;
     if (extension_id == that.extension_id &&
         sub_event_name < that.sub_event_name)
       return true;
@@ skipping 739 matching lines @@
 }
 
 bool ExtensionWebRequestEventRouter::AddEventListener(
     void* profile,
     const std::string& extension_id,
     const std::string& extension_name,
     const std::string& event_name,
     const std::string& sub_event_name,
     const RequestFilter& filter,
     int extra_info_spec,
-    int target_process_id,
-    int target_route_id,
+    int embedder_process_id,
+    int web_view_instance_id,
     base::WeakPtr<IPC::Sender> ipc_sender) {
+
   if (!IsWebRequestEvent(event_name))
     return false;
 
   EventListener listener;
   listener.extension_id = extension_id;
   listener.extension_name = extension_name;
   listener.sub_event_name = sub_event_name;
   listener.filter = filter;
   listener.extra_info_spec = extra_info_spec;
   listener.ipc_sender = ipc_sender;
-  listener.target_process_id = target_process_id;
-  listener.target_route_id = target_route_id;
+  listener.embedder_process_id = embedder_process_id;
+  listener.web_view_instance_id = web_view_instance_id;
 
   if (listeners_[profile][event_name].count(listener) != 0u) {
     // This is likely an abuse of the API by a malicious extension.
     return false;
   }
   listeners_[profile][event_name].insert(listener);
   return true;
 }
 
 void ExtensionWebRequestEventRouter::RemoveEventListener(
@@ skipping 25 matching lines @@
   for (std::set<uint64>::iterator it = found->blocked_requests.begin();
        it != found->blocked_requests.end(); ++it) {
     DecrementBlockCount(profile, extension_id, event_name, *it, NULL);
   }
 
   listeners_[profile][event_name].erase(listener);
 
   helpers::ClearCacheOnNavigation();
 }
 
+void ExtensionWebRequestEventRouter::RemoveWebViewEventListeners(
+    void* profile,
+    const std::string& extension_id,
+    int embedder_process_id,
+    int web_view_instance_id) {
+  // Iterate over all listeners of all WebRequest events to delete
+  // any listeners that belong to the provided <webview>.
+  ListenerMapForProfile& map_for_profile = listeners_[profile];
+  for (ListenerMapForProfile::iterator event_iter = map_for_profile.begin();
+       event_iter != map_for_profile.end(); ++event_iter) {
+    std::vector<EventListener> listeners_to_delete;
+    std::set<EventListener>& listeners = event_iter->second;
+    for (std::set<EventListener>::iterator listener_iter = listeners.begin();
+         listener_iter != listeners.end(); ++listener_iter) {
+      const EventListener& listener = *listener_iter;
+      if (listener.embedder_process_id == embedder_process_id &&
+          listener.web_view_instance_id == web_view_instance_id)
+        listeners_to_delete.push_back(listener);
+    }
+    for (size_t i = 0; i < listeners_to_delete.size(); ++i) {
+      EventListener& listener = listeners_to_delete[i];
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&RemoveEventListenerOnUI,
+                     profile,
+                     listener.sub_event_name,
+                     embedder_process_id,
+                     extension_id));
+    }
+  }
+}
+
 void ExtensionWebRequestEventRouter::OnOTRProfileCreated(
     void* original_profile, void* otr_profile) {
   cross_profile_map_[original_profile] = otr_profile;
   cross_profile_map_[otr_profile] = original_profile;
 }
 
 void ExtensionWebRequestEventRouter::OnOTRProfileDestroyed(
     void* original_profile, void* otr_profile) {
   cross_profile_map_.erase(otr_profile);
   cross_profile_map_.erase(original_profile);
@@ skipping 57 matching lines @@
     int tab_id,
     int window_id,
     int render_process_host_id,
     int routing_id,
     ResourceType::Type resource_type,
     bool is_async_request,
     bool is_request_from_extension,
     int* extra_info_spec,
     std::vector<const ExtensionWebRequestEventRouter::EventListener*>*
         matching_listeners) {
+  std::string web_request_event_name(event_name);
   ExtensionRendererState::WebViewInfo web_view_info;
   bool is_guest = ExtensionRendererState::GetInstance()->
       GetWebViewInfo(render_process_host_id, routing_id, &web_view_info);
-  std::set<EventListener>& listeners = listeners_[profile][event_name];
+  if (is_guest)
+    web_request_event_name.replace(0, sizeof(kWebRequest) - 1, kWebView);
+
+  std::set<EventListener>& listeners =
+      listeners_[profile][web_request_event_name];
   for (std::set<EventListener>::iterator it = listeners.begin();
        it != listeners.end(); ++it) {
     if (!it->ipc_sender.get()) {
       // The IPC sender has been deleted. This listener will be removed soon
       // via a call to RemoveEventListener. For now, just skip it.
       continue;
     }
 
-    if (is_guest && (it->target_process_id != render_process_host_id||
-                     it->target_route_id != routing_id))
+    if (is_guest &&
+        (it->embedder_process_id != web_view_info.embedder_process_id ||
+         it->web_view_instance_id != web_view_info.web_view_instance_id))
       continue;
 
     if (!it->filter.urls.is_empty() && !it->filter.urls.MatchesURL(url))
       continue;
     if (it->filter.tab_id != -1 && tab_id != it->filter.tab_id)
       continue;
     if (it->filter.window_id != -1 && window_id != it->filter.window_id)
       continue;
     if (!it->filter.types.empty() &&
         std::find(it->filter.types.begin(), it->filter.types.end(),
                   resource_type) == it->filter.types.end())
       continue;
 
-    if (!WebRequestPermissions::CanExtensionAccessURL(
+    if (!is_guest && !WebRequestPermissions::CanExtensionAccessURL(
             extension_info_map, it->extension_id, url, crosses_incognito,
             WebRequestPermissions::REQUIRE_HOST_PERMISSION))
       continue;
 
     bool blocking_listener =
         (it->extra_info_spec &
             (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) != 0;
 
     // We do not want to notify extensions about XHR requests that are
     // triggered by themselves. This is a workaround to prevent deadlocks
@@ skipping 667 matching lines @@
         ExtensionWebRequestEventRouter::ExtraInfoSpec::InitFromValue(
             *value, &extra_info_spec));
   }
 
   std::string event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(3, &event_name));
 
   std::string sub_event_name;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(4, &sub_event_name));
 
+  int web_view_instance_id = 0;
+  EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(5, &web_view_instance_id));
+
+  base::WeakPtr<ChromeRenderMessageFilter> ipc_sender = ipc_sender_weak();
+
+  int embedder_process_id =
+      ipc_sender.get() ? ipc_sender->render_process_id() : -1;
+
   const Extension* extension =
       extension_info_map()->extensions().GetByID(extension_id());
   std::string extension_name = extension ? extension->name() : extension_id();
 
+  bool is_guest = web_view_instance_id != 0;
   // We check automatically whether the extension has the 'webRequest'
   // permission. For blocking calls we require the additional permission
   // 'webRequestBlocking'.
-  if ((extra_info_spec &
+  if ((!is_guest && extra_info_spec &
           (ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING |
            ExtensionWebRequestEventRouter::ExtraInfoSpec::ASYNC_BLOCKING)) &&
        !extension->HasAPIPermission(
            extensions::APIPermission::kWebRequestBlocking)) {
     error_ = keys::kBlockingPermissionRequired;
     return false;
   }
 
   // We allow to subscribe to patterns that are broader than the host
   // permissions. E.g., we could subscribe to http://www.example.com/*
   // while having host permissions for http://www.example.com/foo/* and
   // http://www.example.com/bar/*.
   // For this reason we do only a coarse check here to warn the extension
   // developer if he does something obviously wrong.
-  if (extensions::PermissionsData::GetEffectiveHostPermissions(
+  if (!is_guest && extensions::PermissionsData::GetEffectiveHostPermissions(
           extension).is_empty()) {
     error_ = keys::kHostPermissionsRequired;
     return false;
   }
 
   bool success =
       ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
           profile_id(), extension_id(), extension_name,
-          event_name, sub_event_name, filter,
-          extra_info_spec, -1, -1, ipc_sender_weak());
+          event_name, sub_event_name, filter, extra_info_spec,
+          embedder_process_id, web_view_instance_id, ipc_sender_weak());
   EXTENSION_FUNCTION_VALIDATE(success);
 
   helpers::ClearCacheOnNavigation();
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &helpers::NotifyWebRequestAPIUsed,
       profile_id(), make_scoped_refptr(GetExtension())));
 
   return true;
 }
@@ skipping 159 matching lines @@
       } else if ((*it)->name().find("AdBlock") != std::string::npos) {
         adblock = true;
       } else {
         other = true;
       }
     }
   }
 
   host->Send(new ExtensionMsg_UsingWebRequestAPI(adblock, adblock_plus, other));
 }