[Extensions] Short-circuit activity logging if not enabled

extensions/browser/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 "extensions/browser/api/web_request/web_request_api.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 19 matching lines @@
 #include "extensions/browser/api/declarative/rules_registry_service.h"
 #include "extensions/browser/api/declarative_webrequest/request_stage.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_rules_registry.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/web_request/web_request_api_constants.h"
 #include "extensions/browser/api/web_request/web_request_api_helpers.h"
 #include "extensions/browser/api/web_request/web_request_event_details.h"
 #include "extensions/browser/api/web_request/web_request_event_router_delegate.h"
 #include "extensions/browser/api/web_request/web_request_time_tracker.h"
+#include "extensions/browser/api_activity_monitor.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/guest_view/guest_view_events.h"
 #include "extensions/browser/guest_view/web_view/web_view_constants.h"
 #include "extensions/browser/guest_view/web_view/web_view_renderer_state.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/browser/io_thread_extension_message_filter.h"
@@ skipping 518 matching lines @@
 //
 // ExtensionWebRequestEventRouter
 //
 
 // static
 ExtensionWebRequestEventRouter* ExtensionWebRequestEventRouter::GetInstance() {
   return base::Singleton<ExtensionWebRequestEventRouter>::get();
 }
 
 ExtensionWebRequestEventRouter::ExtensionWebRequestEventRouter()
-    : request_time_tracker_(new ExtensionWebRequestTimeTracker) {
-  web_request_event_router_delegate_.reset(
-      ExtensionsAPIClient::Get()->CreateWebRequestEventRouterDelegate());
-}
+    : request_time_tracker_(new ExtensionWebRequestTimeTracker),
+      web_request_event_router_delegate_(
+          ExtensionsAPIClient::Get()->CreateWebRequestEventRouterDelegate()) {}
 
 ExtensionWebRequestEventRouter::~ExtensionWebRequestEventRouter() {
 }
 
 void ExtensionWebRequestEventRouter::RegisterRulesRegistry(
     void* browser_context,
     int rules_registry_id,
     scoped_refptr<WebRequestRulesRegistry> rules_registry) {
   RulesRegistryKey key(browser_context, rules_registry_id);
   if (rules_registry.get())
@@ skipping 772 matching lines @@
       continue;
     }
 
     if (!is_web_view_guest) {
       PermissionsData::AccessType access =
           WebRequestPermissions::CanExtensionAccessURL(
               extension_info_map, listener.extension_id, url, frame_data.tab_id,
               crosses_incognito,
               WebRequestPermissions::REQUIRE_HOST_PERMISSION);
       if (access != PermissionsData::ACCESS_ALLOWED) {
-        if (access == PermissionsData::ACCESS_WITHHELD) {
+        if (access == PermissionsData::ACCESS_WITHHELD &&
+            web_request_event_router_delegate_) {
           web_request_event_router_delegate_->NotifyWebRequestWithheld(
               render_process_id, render_frame_id, listener.extension_id);
         }
         continue;
       }
     }
 
     bool blocking_listener =
         (listener.extra_info_spec &
          (ExtraInfoSpec::BLOCKING | ExtraInfoSpec::ASYNC_BLOCKING)) != 0;
@@ skipping 211 matching lines @@
     details->Set(
         activity_log::kResponseCookieModificationsKey,
         SummarizeCookieModifications(delta.response_cookie_modifications));
   }
 
   return details;
 }
 
 }  // namespace
 
-void ExtensionWebRequestEventRouter::LogExtensionActivity(
-    void* browser_context_id,
-    bool is_incognito,
-    const std::string& extension_id,
-    const GURL& url,
-    const std::string& api_call,
-    std::unique_ptr<base::DictionaryValue> details) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&ExtensionWebRequestEventRouter::LogExtensionActivity,
-                    base::Unretained(this),
-                    browser_context_id,
-                    is_incognito,
-                    extension_id,
-                    url,
-                    api_call,
-                    base::Passed(&details)));
-  } else {
-    if (web_request_event_router_delegate_) {
-      web_request_event_router_delegate_->LogExtensionActivity(
-          reinterpret_cast<content::BrowserContext*>(browser_context_id),
-          is_incognito, extension_id, url, api_call, std::move(details));
-    }
-  }
-}
-
 void ExtensionWebRequestEventRouter::DecrementBlockCount(
     void* browser_context,
     const std::string& extension_id,
     const std::string& event_name,
     uint64_t request_id,
     EventResponse* response) {
   std::unique_ptr<EventResponse> response_scoped(response);
 
   // It's possible that this request was deleted, or cancelled by a previous
   // event handler. If so, ignore this response.
   auto it = blocked_requests_.find(request_id);
   if (it == blocked_requests_.end())
     return;
 
   BlockedRequest& blocked_request = it->second;
   int num_handlers_blocking = --blocked_request.num_handlers_blocking;
   CHECK_GE(num_handlers_blocking, 0);
 
   if (response) {
     helpers::EventResponseDelta* delta =
         CalculateDelta(&blocked_request, response);
 
-    LogExtensionActivity(browser_context,
-                         blocked_request.is_incognito,
-                         extension_id,
-                         blocked_request.request->url(),
-                         event_name,
-                         SummarizeResponseDelta(event_name, *delta));
+    activity_monitor::OnWebRequestApiUsed(
+        static_cast<content::BrowserContext*>(browser_context), extension_id,
+        blocked_request.request->url(), blocked_request.is_incognito,
+        event_name, SummarizeResponseDelta(event_name, *delta));
 
     blocked_request.response_deltas.push_back(
         linked_ptr<helpers::EventResponseDelta>(delta));
   }
 
   base::TimeDelta block_time =
       base::Time::Now() - blocked_request.blocking_time;
   if (!extension_id.empty()) {
     request_time_tracker_->IncrementExtensionBlockTime(
         extension_id, request_id, block_time);
@@ skipping 622 matching lines @@
   // Continue gracefully.
   RunSync();
 }
 
 bool WebRequestHandlerBehaviorChangedFunction::RunSync() {
   helpers::ClearCacheOnNavigation();
   return true;
 }
 
 }  // namespace extensions