<webview>: Implement declarativeWebRequest 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 59 matching lines @@
 using chrome::VersionInfo;
 using content::BrowserMessageFilter;
 using content::BrowserThread;
 using content::ResourceRequestInfo;
 using extensions::ErrorUtils;
 using extensions::Extension;
 using extensions::ExtensionWarning;
 using extensions::ExtensionWarningService;
 using extensions::ExtensionWarningSet;
 using extensions::Feature;
+using extensions::RulesRegistryService;
 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 {
 
@@ skipping 502 matching lines @@
 
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter()
     : request_time_tracker_(new ExtensionWebRequestTimeTracker) {
 }
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 void ExtensionWebRequestEventRouter::RegisterRulesRegistry(
     void* profile,
+    const RulesRegistryService::WebViewKey& webview_key,
     scoped_refptr<extensions::WebRequestRulesRegistry> rules_registry) {
+  std::pair<void*, RulesRegistryService::WebViewKey> key(profile, webview_key);

[vabr (Chromium), 2013/10/25 20:40:24]

Use the already defined typedef RulesRegistryKey instead?

[Fady Samuel, 2013/10/25 22:48:08]

This is a <std::string, WebViewKey> pair, instead of a <Profile, WebViewKey>.

These are different keys. In RulesRegistryService we have different event types
that may or may not correspond to WebRequest API. Here all events are WebRequest
API events.

[vabr (Chromium), 2013/10/28 14:46:09]

I think there is a misunderstanding.
In web_request_api.h, line 427 you define
ExtensionWebRequestEventRouter::RulesRegistryKey. This is the key used by
|rules_registries_| (declared just below that typedef).
Now here, in web_request_api.cc, in RegisterRulesRegistry, |key| is obviously a
key to be used for |rules_registries_|, so its type should be
ExtensionWebRequestEventRouter::RulesRegistryKey, right?

   if (rules_registry.get())
-    rules_registries_[profile] = rules_registry;
+    rules_registries_[key] = rules_registry;
   else
-    rules_registries_.erase(profile);
+    rules_registries_.erase(key);
 }
 
 int ExtensionWebRequestEventRouter::OnBeforeRequest(
     void* profile,
     ExtensionInfoMap* extension_info_map,
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     GURL* new_url) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile ||
@@ skipping 1219 matching lines @@
   return rv;
 }
 
 bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
     void* profile,
     ExtensionInfoMap* 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()->

[vabr (Chromium), 2013/10/25 20:40:24]

What does "guest" mean in this context?

[Fady Samuel, 2013/10/25 22:48:08]

The content of a <webview> lives in an different process referred to as the
"guest".

[vabr (Chromium), 2013/10/28 14:46:09]

OK, that makes sense. Could you please add this explanation as a comment in the
code?

+      GetWebViewInfo(render_process_host_id, routing_id, &webview_info);
+
+  RulesRegistryService::WebViewKey webview_key(
+      is_guest ? webview_info.embedder_process_id : 0,
+      webview_info.instance_id);
+  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.
   typedef std::pair<extensions::WebRequestRulesRegistry*, bool>
       RelevantRegistry;
   typedef std::vector<RelevantRegistry> RelevantRegistries;
   RelevantRegistries relevant_registries;
 
-  if (rules_registries_.find(profile) != rules_registries_.end()) {
+  if (rules_registries_.find(rules_key) != rules_registries_.end()) {
     relevant_registries.push_back(
-        std::make_pair(rules_registries_[profile].get(), false));
+        std::make_pair(rules_registries_[rules_key].get(), false));
   }
 
   void* cross_profile = GetCrossProfile(profile);
   if (cross_profile &&
-      rules_registries_.find(cross_profile) != rules_registries_.end()) {
+      rules_registries_.find(rules_key) != rules_registries_.end()) {

[vabr (Chromium), 2013/10/25 20:40:24]

|cross_profile| is not contained in rules_key -- is that what you wanted here
and on line 1896 below?
If so, you can at least cache the test on this line (the exactly same test is
also on line 1887.

[Fady Samuel, 2013/10/25 22:48:08]

Good catch! Fixed. Added a cross_profile_rules_key.

     relevant_registries.push_back(
-        std::make_pair(rules_registries_[cross_profile].get(), true));
+        std::make_pair(rules_registries_[rules_key].get(), true));
   }
 
   // The following block is experimentally enabled and its impact on load time
   // logged with UMA Extensions.NetworkDelayRegistryLoad. crbug.com/175961
   for (RelevantRegistries::iterator i = relevant_registries.begin();
        i != relevant_registries.end(); ++i) {
     extensions::WebRequestRulesRegistry* rules_registry = i->first;
     if (!rules_registry->ready().is_signaled()) {
       // The rules registry is still loading. Block this request until it
       // finishes.
@@ skipping 405 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));
 }