[Extensions] Add renderer-side logic to short circuit activity logging

extensions/renderer/user_script_set.cc

 // Copyright 2014 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/renderer/user_script_set.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 52 matching lines @@
       continue;
     DCHECK(!script->extension_id().empty());
     ids->insert(script->extension_id());
   }
 }
 
 void UserScriptSet::GetInjections(
     std::vector<std::unique_ptr<ScriptInjection>>* injections,
     content::RenderFrame* render_frame,
     int tab_id,
-    UserScript::RunLocation run_location) {
+    UserScript::RunLocation run_location,
+    bool log_activity) {
   GURL document_url = GetDocumentUrlForFrame(render_frame->GetWebFrame());
   for (const UserScript* script : scripts_) {
-    std::unique_ptr<ScriptInjection> injection =
-        GetInjectionForScript(script, render_frame, tab_id, run_location,
-                              document_url, false /* is_declarative */);
+    std::unique_ptr<ScriptInjection> injection = GetInjectionForScript(
+        script, render_frame, tab_id, run_location, document_url,
+        false /* is_declarative */, log_activity);
     if (injection.get())
       injections->push_back(std::move(injection));
   }
 }
 
 bool UserScriptSet::UpdateUserScripts(base::SharedMemoryHandle shared_memory,
                                       const std::set<HostID>& changed_hosts,
                                       bool whitelisted_only) {
   bool only_inject_incognito =
       ExtensionsRendererClient::Get()->IsIncognitoProcess();
@@ skipping 64 matching lines @@
                     observers_,
                     OnUserScriptsUpdated(changed_hosts, scripts_.get()));
   return true;
 }
 
 std::unique_ptr<ScriptInjection> UserScriptSet::GetDeclarativeScriptInjection(
     int script_id,
     content::RenderFrame* render_frame,
     int tab_id,
     UserScript::RunLocation run_location,
-    const GURL& document_url) {
+    const GURL& document_url,
+    bool log_activity) {
   for (const UserScript* script : scripts_) {
     if (script->id() == script_id) {
-      return GetInjectionForScript(script,
-                                   render_frame,
-                                   tab_id,
-                                   run_location,
-                                   document_url,
-                                   true /* is_declarative */);
+      return GetInjectionForScript(script, render_frame, tab_id, run_location,
+                                   document_url, true /* is_declarative */,
+                                   log_activity);
     }
   }
   return std::unique_ptr<ScriptInjection>();
 }
 
 std::unique_ptr<ScriptInjection> UserScriptSet::GetInjectionForScript(
     const UserScript* script,
     content::RenderFrame* render_frame,
     int tab_id,
     UserScript::RunLocation run_location,
     const GURL& document_url,
-    bool is_declarative) {
+    bool is_declarative,
+    bool log_activity) {
   std::unique_ptr<ScriptInjection> injection;
   std::unique_ptr<const InjectionHost> injection_host;
   blink::WebLocalFrame* web_frame = render_frame->GetWebFrame();
 
   const HostID& host_id = script->host_id();
   if (host_id.type() == HostID::EXTENSIONS) {
     injection_host = ExtensionInjectionHost::Create(host_id.id());
     if (!injection_host)
       return injection;
   } else {
@@ skipping 20 matching lines @@
       PermissionsData::ACCESS_DENIED) {
     return injection;
   }
 
   bool inject_css = !script->css_scripts().empty() &&
                     run_location == UserScript::DOCUMENT_START;
   bool inject_js =
       !script->js_scripts().empty() && script->run_location() == run_location;
   if (inject_css || inject_js) {
     injection.reset(new ScriptInjection(std::move(injector), render_frame,
-                                        std::move(injection_host),
-                                        run_location));
+                                        std::move(injection_host), run_location,
+                                        log_activity));
   }
   return injection;
 }
 
 }  // namespace extensions