Persist declarative rules to the extension state store.

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/json/json_writer.h"
@@ skipping 471 matching lines @@
 
   request_time_tracker_->LogRequestStartTime(request->identifier(),
                                              base::Time::Now(),
                                              request->url(),
                                              profile);
 
   // Whether to initialized blocked_requests_.
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
-      ProcessDeclarativeRules(request, extensions::ON_BEFORE_REQUEST, NULL);
+      ProcessDeclarativeRules(profile, keys::kOnBeforeRequest, request,
+                              extensions::ON_BEFORE_REQUEST, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map, keys::kOnBeforeRequest,
                            request, &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeRequest)) {
     ListValue args;
     DictionaryValue* dict = new DictionaryValue();
     ExtractRequestInfo(request, dict);
@@ skipping 27 matching lines @@
     net::URLRequest* request,
     const net::CompletionCallback& callback,
     net::HttpRequestHeaders* headers) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile || helpers::HideRequestForURL(request->url()))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
-      ProcessDeclarativeRules(request, extensions::ON_BEFORE_SEND_HEADERS,
-                              NULL);
+      ProcessDeclarativeRules(profile, keys::kOnBeforeSendHeaders, request,
+                              extensions::ON_BEFORE_SEND_HEADERS, NULL);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnBeforeSendHeaders, request,
                            &extra_info_spec);
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnBeforeSendHeaders)) {
     ListValue args;
     DictionaryValue* dict = new DictionaryValue();
@@ skipping 62 matching lines @@
     const net::CompletionCallback& callback,
     net::HttpResponseHeaders* original_response_headers,
     scoped_refptr<net::HttpResponseHeaders>* override_response_headers) {
   // We hide events from the system context as well as sensitive requests.
   if (!profile || helpers::HideRequestForURL(request->url()))
     return net::OK;
 
   bool initialize_blocked_requests = false;
 
   initialize_blocked_requests |=
-      ProcessDeclarativeRules(request, extensions::ON_HEADERS_RECEIVED,
+      ProcessDeclarativeRules(profile, keys::kOnHeadersReceived, request,
+                              extensions::ON_HEADERS_RECEIVED,
                               original_response_headers);
 
   int extra_info_spec = 0;
   std::vector<const EventListener*> listeners =
       GetMatchingListeners(profile, extension_info_map,
                            keys::kOnHeadersReceived, request,
                            &extra_info_spec);
 
   if (!listeners.empty() &&
       !GetAndSetSignaled(request->identifier(), kOnHeadersReceived)) {
@@ skipping 627 matching lines @@
   CHECK_GE(num_handlers_blocking, 0);
 
   if (response) {
     blocked_request.response_deltas.push_back(
         linked_ptr<helpers::EventResponseDelta>(
             CalculateDelta(&blocked_request, response)));
   }
 
   base::TimeDelta block_time =
       base::Time::Now() - blocked_request.blocking_time;
-  request_time_tracker_->IncrementExtensionBlockTime(
-      extension_id, request_id, block_time);
+  if (!extension_id.empty())
+    request_time_tracker_->IncrementExtensionBlockTime(
+        extension_id, request_id, block_time);

[battre, 2012/06/15 22:56:49]

should we add a UMA statistic to measure the network delays at browser start
here? I am not sure how much this would tell us though as everything is slow
during browser startup. So if the UMA statistic tells us 10s, we don't know
whether the request had be answered instantly, if there was no need to load
declarative webrequest rules.

[Matt Perry, 2012/06/18 21:01:01]

Done.

 
   if (num_handlers_blocking == 0) {
     ExecuteDeltas(profile, request_id, true);
   } else {
     // Update the URLRequest to indicate it is now blocked on a different
     // extension.
     std::set<EventListener>& listeners = listeners_[profile][event_name];
 
     for (std::set<EventListener>::iterator it = listeners.begin();
          it != listeners.end(); ++it) {
@@ skipping 108 matching lines @@
     blocked_requests_.erase(request_id);
     if (call_callback)
       callback.Run(response);
   } else {
     blocked_requests_.erase(request_id);
   }
   return rv;
 }
 
 bool ExtensionWebRequestEventRouter::ProcessDeclarativeRules(
+    void* profile,
+    const std::string& event_name,
     net::URLRequest* request,
     extensions::RequestStages request_stage,
     net::HttpResponseHeaders* original_response_headers) {
   if (!rules_registry_.get())
     return false;
 
+  if (!rules_registry_->IsReady()) {

[battre, 2012/06/15 22:56:49]

nice! the architecture is really flexible.

[Matt Perry, 2012/06/18 21:01:01]

Agreed, I was pleasantly surprised with how simple this was to hook up. Great
job with the rules API and and webRequest hooks!

+    // The rules registry is still loading. Block this request until it
+    // finishes.
+    EventResponse* response = NULL;
+    rules_registry_->AddReadyCallback(
+        base::Bind(&ExtensionWebRequestEventRouter::DecrementBlockCount,
+                   AsWeakPtr(), profile, std::string(), event_name,
+                   request->identifier(), response));
+    blocked_requests_[request->identifier()].num_handlers_blocking++;

[Matt Perry, 2012/06/18 21:01:01]

BTW I had to add more initialization of blocked_requests_ here to mimic what
DispatchEvent does.

+    return true;
+  }
+
   base::Time start = base::Time::Now();
 
   // TODO(battre): Annotate deltas with extension IDs, so that we can
   // - Sort deltas by precedence
   // - Check whether extensions have host permissions.
   extensions::WebRequestRule::OptionalRequestData optional_request_data;
   optional_request_data.original_response_headers =
       original_response_headers;
   std::list<linked_ptr<helpers::EventResponseDelta> > result =
       rules_registry_->CreateDeltas(request, request_stage,
@@ skipping 333 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));
 }