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();
+}
+
+bool IsWebViewGuest(net::URLRequest* request,
+                    ExtensionRendererState::WebViewInfo* webview_info) {

[battre, 2014/05/28 13:24:45]

I think this function should be called Get[something] to indicate that it
modifies webview_info. Also some documentation would be useful.

[Fady Samuel, 2014/05/28 14:18:24]

Done.

+  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, webview_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 182 matching lines @@
   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.

[battre, 2014/05/28 13:24:45]

I guess this needs to be updated.

[Fady Samuel, 2014/05/28 14:18:24]

Done.

 void SendOnMessageEventOnUI(
     void* profile_id,
     const std::string& extension_id,
+    int is_guest,

[battre, 2014/05/28 13:24:45]

What does |is_guest| mean?

Would you mind adding some documentation to c/b/guest_view as well. E.g. to
guest_view.h. It would be tremendously helpful as an entry point for somebody
who does not have the slightest clue what a guest view is. ;-)

[Fady Samuel, 2014/05/28 14:18:24]

Done.

+    const ExtensionRendererState::WebViewInfo& webview_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;
+  event_filtering_info.SetURL(GURL());
+  if (is_guest)
+    event_filtering_info.SetInstanceID(webview_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_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 1388 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 webview_info;
+      bool is_guest = IsWebViewGuest(blocked_request.request, &webview_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_guest,
+                     webview_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);
+  bool is_guest = IsWebViewGuest(request, &webview_info);
 
   RulesRegistryService::WebViewKey webview_key(
       is_guest ? webview_info.embedder_process_id : 0,
       is_guest ? webview_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 492 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));
 }