Declarative WR: Enable and measure request blocking until registries are loaded.

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 1616 matching lines @@
         std::make_pair(rules_registries_[profile].get(), false));
   }
 
   void* cross_profile = GetCrossProfile(profile);
   if (cross_profile &&
       rules_registries_.find(cross_profile) != rules_registries_.end()) {
     relevant_registries.push_back(
         std::make_pair(rules_registries_[cross_profile].get(), true));
   }
 
-  // TODO(mpcomplete): Eventually we'll want to turn this on, but for now,
-  // we won't block startup for declarative webrequest. I want to measure
-  // its effect first.
-#if defined(BLOCK_STARTUP_ON_DECLARATIVE_RULES)
+  // 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->IsReady()) {
       // The rules registry is still loading. Block this request until it
       // finishes.
       rules_registry->AddReadyCallback(
           base::Bind(&ExtensionWebRequestEventRouter::OnRulesRegistryReady,
                      AsWeakPtr(), profile, event_name, request->identifier(),
                      request_stage));
       blocked_requests_[request->identifier()].num_handlers_blocking++;
       blocked_requests_[request->identifier()].request = request;
       blocked_requests_[request->identifier()].blocking_time =
           base::Time::Now();
       blocked_requests_[request->identifier()].original_response_headers =
           original_response_headers;
       blocked_requests_[request->identifier()].extension_info_map =
           extension_info_map;
       return true;
     }
   }
-#endif
 
   base::Time start = base::Time::Now();
 
   bool deltas_created = false;
   for (RelevantRegistries::iterator i = relevant_registries.begin();
        i != relevant_registries.end(); ++i) {
     extensions::WebRequestRulesRegistry* rules_registry =
         i->first;
     helpers::EventResponseDeltas result =
         rules_registry->CreateDeltas(
@@ skipping 21 matching lines @@
     void* profile,
     const std::string& event_name,
     uint64 request_id,
     extensions::RequestStage request_stage) {
   // It's possible that this request was deleted, or cancelled by a previous
   // event handler. If so, ignore this response.
   if (blocked_requests_.find(request_id) == blocked_requests_.end())
     return;
 
   BlockedRequest& blocked_request = blocked_requests_[request_id];
+  base::TimeDelta block_time =
+      base::Time::Now() - blocked_request.blocking_time;
+  UMA_HISTOGRAM_TIMES("Extensions.NetworkDelayRegistryLoad", block_time);
+
   ProcessDeclarativeRules(profile, blocked_request.extension_info_map,
                           event_name, blocked_request.request, request_stage,
                           blocked_request.original_response_headers);
   // Reset to NULL so that nobody relies on this being set.
   blocked_request.extension_info_map = NULL;
   DecrementBlockCount(profile, std::string(), event_name, request_id, NULL);
 }
 
 bool ExtensionWebRequestEventRouter::GetAndSetSignaled(uint64 request_id,
                                                        EventTypes event_type) {
@@ skipping 316 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));
 }