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);
+  } else {
+    // |extension_id| is empty for requests blocked on startup waiting for the
+    // declarative rules to be read from disk.
+    UMA_HISTOGRAM_TIMES("Extensions.NetworkDelayStartup", block_time);
+  }
 
   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()) {
+    // 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));

[battre, 2012/06/26 07:59:55]

I think this is actually incorrect. We need to decrement the block count but we
also need to process the declarative rules.

+    blocked_requests_[request->identifier()].num_handlers_blocking++;
+    blocked_requests_[request->identifier()].request = request;
+    blocked_requests_[request->identifier()].blocking_time = base::Time::Now();
+    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));
 }