Fix the Declarative WebRequest API for <webview>

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 15 matching lines @@
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry.h"
 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/upload_data_presenter.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_constants.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api_helpers.h"
 #include "chrome/browser/extensions/api/web_request/web_request_time_tracker.h"
 #include "chrome/browser/extensions/extension_renderer_state.h"
 #include "chrome/browser/extensions/extension_warning_service.h"
 #include "chrome/browser/extensions/extension_warning_set.h"
+#include "chrome/browser/guest_view/web_view/web_view_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/web_request.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/user_metrics.h"
@@ skipping 110 matching lines @@
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
 
   // If this request was not created by the ResourceDispatcher, |info| is NULL.
   // All requests from extensions are created by the ResourceDispatcher.
   if (!info)
     return false;
 
   return extension_info_map->process_map().Contains(info->GetChildID());
 }
 
+void ExtractRequestRoutingInfo(net::URLRequest* request,
+                               int* render_process_host_id,
+                               int* routing_id) {
+  if (!request->GetUserData(NULL))
+    return;
+  const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
+  *render_process_host_id = info->GetChildID();
+  *routing_id = info->GetRouteID();
+}
+
+// Given a |request|, this function determines whether it originated from
+// a <webview> guest process or not. If it is from a <webview> guest process,
+// then |web_view_info| is returned with information about the instance ID
+// that uniquely identifies the <webview> and its embedder.
+bool GetWebViewInfo(net::URLRequest* request,
+                    ExtensionRendererState::WebViewInfo* web_view_info) {
+  int render_process_host_id = -1;
+  int routing_id = -1;
+  ExtractRequestRoutingInfo(request, &render_process_host_id, &routing_id);
+  return ExtensionRendererState::GetInstance()->
+      GetWebViewInfo(render_process_host_id, routing_id, web_view_info);
+}
+
 void ExtractRequestInfoDetails(net::URLRequest* request,
                                bool* is_main_frame,
                                int64* frame_id,
                                bool* parent_is_main_frame,
                                int64* parent_frame_id,
                                int* tab_id,
                                int* window_id,
                                int* render_process_host_id,
                                int* routing_id,
                                ResourceType::Type* resource_type) {
@@ skipping 180 matching lines @@
     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.
+// Sends an event to subscribers of chrome.declarativeWebRequest.onMessage or
+// to subscribers of webview.onMessage if the action is being operated upon
+// a <webview> guest renderer.
 // |extension_id| identifies the extension that sends and receives the event.
+// |is_web_view_guest| indicates whether the action is for a <webview>.
+// |web_view_info| is a struct containing information about the <webview>
+// embedder.
 // |event_argument| is passed to the event listener.
 void SendOnMessageEventOnUI(
     void* profile_id,
     const std::string& extension_id,
+    bool is_web_view_guest,
+    const ExtensionRendererState::WebViewInfo& web_view_info,
     scoped_ptr<base::DictionaryValue> event_argument) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Profile* profile = reinterpret_cast<Profile*>(profile_id);
   if (!g_browser_process->profile_manager()->IsValidProfile(profile))
     return;
 
   scoped_ptr<base::ListValue> event_args(new base::ListValue);
   event_args->Append(event_argument.release());
 
   extensions::EventRouter* event_router = extensions::EventRouter::Get(profile);
 
+  extensions::EventFilteringInfo event_filtering_info;
+  // The instance ID uniquely identifies a <webview> instance within an embedder
+  // process. We use a filter here so that only event listeners for a particular
+  // <webview> will fire.
+  if (is_web_view_guest)
+    event_filtering_info.SetInstanceID(web_view_info.instance_id);
+
   scoped_ptr<extensions::Event> event(new extensions::Event(
-      declarative_keys::kOnMessage, event_args.Pass(), profile,
-      GURL(), extensions::EventRouter::USER_GESTURE_UNKNOWN,
-      extensions::EventFilteringInfo()));
+      is_web_view_guest ? webview::kEventMessage : declarative_keys::kOnMessage,
+      event_args.Pass(), profile, GURL(),
+      extensions::EventRouter::USER_GESTURE_UNKNOWN,
+      event_filtering_info));
   event_router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void RemoveEventListenerOnIOThread(
     content::BrowserContext* browser_context,
     const std::string& extension_id,
     const std::string& sub_event_name) {
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       browser_context, extension_id, sub_event_name);
 }
@@ skipping 835 matching lines @@
     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 embedder_process_id,
     int webview_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;
@@ skipping 158 matching lines @@
     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 webview_info;
-  bool is_guest = ExtensionRendererState::GetInstance()->
-      GetWebViewInfo(render_process_host_id, routing_id, &webview_info);
-  if (is_guest)
+  ExtensionRendererState::WebViewInfo web_view_info;
+  bool is_web_view_guest = ExtensionRendererState::GetInstance()->
+      GetWebViewInfo(render_process_host_id, routing_id, &web_view_info);
+  if (is_web_view_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->embedder_process_id != webview_info.embedder_process_id ||
-         it->webview_instance_id != webview_info.instance_id))
+    if (is_web_view_guest &&
+        (it->embedder_process_id != web_view_info.embedder_process_id ||
+         it->webview_instance_id != web_view_info.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 (!is_guest && !WebRequestPermissions::CanExtensionAccessURL(
+    if (!is_web_view_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 321 matching lines @@
     void* profile,
     const BlockedRequest& blocked_request) {
   const helpers::EventResponseDeltas& deltas = blocked_request.response_deltas;
   for (helpers::EventResponseDeltas::const_iterator delta = deltas.begin();
        delta != deltas.end(); ++delta) {
     const std::set<std::string>& messages = (*delta)->messages_to_extension;
     for (std::set<std::string>::const_iterator message = messages.begin();
          message != messages.end(); ++message) {
       scoped_ptr<base::DictionaryValue> argument(new base::DictionaryValue);
       ExtractRequestInfo(blocked_request.request, argument.get());
+      ExtensionRendererState::WebViewInfo web_view_info;
+      bool is_web_view_guest = GetWebViewInfo(blocked_request.request,
+                                              &web_view_info);
       argument->SetString(keys::kMessageKey, *message);
       argument->SetString(keys::kStageKey,
                           GetRequestStageAsString(blocked_request.event));
 
       BrowserThread::PostTask(
           BrowserThread::UI,
           FROM_HERE,
           base::Bind(&SendOnMessageEventOnUI,
                      profile,
                      (*delta)->extension_id,
+                     is_web_view_guest,
+                     web_view_info,
                      base::Passed(&argument)));
     }
   }
 }
 
 int ExtensionWebRequestEventRouter::ExecuteDeltas(
     void* profile,
     uint64 request_id,
     bool call_callback) {
   BlockedRequest& blocked_request = blocked_requests_[request_id];
@@ skipping 94 matching lines @@
   return rv;
 }
 
 bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
     void* profile,
     InfoMap* extension_info_map,
     const std::string& event_name,
     net::URLRequest* request,
     extensions::RequestStage request_stage,
     const net::HttpResponseHeaders* original_response_headers) {
-  bool is_main_frame = false;
-  int64 frame_id = -1;
-  bool parent_is_main_frame = false;
-  int64 parent_frame_id = -1;
-  int tab_id = -1;
-  int window_id = -1;
-  int render_process_host_id = -1;
-  int routing_id = -1;
-  ResourceType::Type resource_type = ResourceType::LAST_TYPE;
-
-  ExtractRequestInfoDetails(request, &is_main_frame, &frame_id,
-                            &parent_is_main_frame, &parent_frame_id,
-                            &tab_id, &window_id, &render_process_host_id,
-                            &routing_id, &resource_type);
-  ExtensionRendererState::WebViewInfo webview_info;
-  bool is_guest = ExtensionRendererState::GetInstance()->
-      GetWebViewInfo(render_process_host_id, routing_id, &webview_info);
+  ExtensionRendererState::WebViewInfo web_view_info;
+  bool is_web_view_guest = GetWebViewInfo(request, &web_view_info);
 
   RulesRegistryService::WebViewKey webview_key(
-      is_guest ? webview_info.embedder_process_id : 0,
-      is_guest ? webview_info.instance_id : 0);
+      is_web_view_guest ? web_view_info.embedder_process_id : 0,
+      is_web_view_guest ? web_view_info.instance_id : 0);
   RulesRegistryKey rules_key(profile, webview_key);
-
   // If this check fails, check that the active stages are up-to-date in
   // browser/extensions/api/declarative_webrequest/request_stage.h .
   DCHECK(request_stage & extensions::kActiveStages);
 
   // Rules of the current |profile| may apply but we need to check also whether
   // there are applicable rules from extensions whose background page
   // spans from regular to incognito mode.
 
   // First parameter identifies the registry, the second indicates whether the
   // registry belongs to the cross profile.
@@ skipping 223 matching lines @@
 
   base::WeakPtr<extensions::ExtensionMessageFilter> 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 = webview_instance_id != 0;
+  bool is_web_view_guest = webview_instance_id != 0;
   // We check automatically whether the extension has the 'webRequest'
   // permission. For blocking calls we require the additional permission
   // 'webRequestBlocking'.
-  if ((!is_guest && extra_info_spec &
+  if ((!is_web_view_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 (!is_guest && extensions::PermissionsData::GetEffectiveHostPermissions(
+  if (!is_web_view_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,
           embedder_process_id, webview_instance_id, ipc_sender_weak());
@@ skipping 229 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));
 }