Split content script injections into multiple tasks

extensions/common/feature_switch.cc

 // Copyright 2013 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/common/feature_switch.h"
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "extensions/common/switches.h"
 
 namespace extensions {
 
 namespace {
 
 // The switch load-media-router-component-extension is defined in
 // chrome/common/chrome_switches.cc, but we can't depend on chrome here.
 const char kLoadMediaRouterComponentExtensionFlag[] =
     "load-media-router-component-extension";
 
+const char kYieldBetweenContentScriptRuns[] = "YieldBetweenContentScriptRuns";
+
 class CommonSwitches {
  public:
   CommonSwitches()
       : force_dev_mode_highlighting(switches::kForceDevModeHighlighting,
                                     FeatureSwitch::DEFAULT_DISABLED),
         prompt_for_external_extensions(
 #if defined(CHROMIUM_BUILD)
             switches::kPromptForExternalExtensions,
 #else
             nullptr,
@@ skipping 14 matching lines @@
         trace_app_source(switches::kTraceAppSource,
                          FeatureSwitch::DEFAULT_ENABLED),
         load_media_router_component_extension(
             kLoadMediaRouterComponentExtensionFlag,
 #if defined(GOOGLE_CHROME_BUILD)
             FeatureSwitch::DEFAULT_ENABLED),
 #else
             FeatureSwitch::DEFAULT_DISABLED),
 #endif  // defined(GOOGLE_CHROME_BUILD)
         native_crx_bindings(switches::kNativeCrxBindings,
-                            FeatureSwitch::DEFAULT_DISABLED) {
+                            FeatureSwitch::DEFAULT_DISABLED),
+        yield_between_content_script_runs(
+            switches::kYieldBetweenContentScriptRuns,
+            kYieldBetweenContentScriptRuns,

[Devlin, 2017/03/10 03:18:45]

We should rename this to be kYieldBetweenContentScriptRunsFieldTrial or similar
to differentiate.

[Kunihiko Sakamoto, 2017/03/10 07:07:28]

Done.

+            FeatureSwitch::DEFAULT_DISABLED) {
   }
 
   FeatureSwitch force_dev_mode_highlighting;
 
   // Should we prompt the user before allowing external extensions to install?
   // Default is yes.
   FeatureSwitch prompt_for_external_extensions;
 
   FeatureSwitch error_console;
   FeatureSwitch enable_override_bookmarks_ui;
   FeatureSwitch extension_action_redesign;
   FeatureSwitch scripts_require_action;
   FeatureSwitch embedded_extension_options;
   FeatureSwitch trace_app_source;
   FeatureSwitch load_media_router_component_extension;
   FeatureSwitch native_crx_bindings;
+  FeatureSwitch yield_between_content_script_runs;
 };
 
 base::LazyInstance<CommonSwitches> g_common_switches =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 FeatureSwitch* FeatureSwitch::force_dev_mode_highlighting() {
   return &g_common_switches.Get().force_dev_mode_highlighting;
 }
@@ skipping 17 matching lines @@
 }
 FeatureSwitch* FeatureSwitch::trace_app_source() {
   return &g_common_switches.Get().trace_app_source;
 }
 FeatureSwitch* FeatureSwitch::load_media_router_component_extension() {
   return &g_common_switches.Get().load_media_router_component_extension;
 }
 FeatureSwitch* FeatureSwitch::native_crx_bindings() {
   return &g_common_switches.Get().native_crx_bindings;
 }
+FeatureSwitch* FeatureSwitch::yield_between_content_script_runs() {
+  return &g_common_switches.Get().yield_between_content_script_runs;
+}
 
 FeatureSwitch::ScopedOverride::ScopedOverride(FeatureSwitch* feature,
                                               bool override_value)
     : feature_(feature),
       previous_value_(feature->GetOverrideValue()) {
   feature_->SetOverrideValue(
       override_value ? OVERRIDE_ENABLED : OVERRIDE_DISABLED);
 }
 
 FeatureSwitch::ScopedOverride::~ScopedOverride() {
@@ skipping 20 matching lines @@
     : FeatureSwitch(command_line, switch_name, nullptr, default_value) {}
 
 FeatureSwitch::FeatureSwitch(const base::CommandLine* command_line,
                              const char* switch_name,
                              const char* field_trial_name,
                              DefaultValue default_value)
     : command_line_(command_line),
       switch_name_(switch_name),
       field_trial_name_(field_trial_name),
       default_value_(default_value == DEFAULT_ENABLED),
-      override_value_(OVERRIDE_NONE) {}
+      override_value_(OVERRIDE_NONE),
+      cached_value_(NOT_CACHED) {}
 
 bool FeatureSwitch::IsEnabled() const {
   if (override_value_ != OVERRIDE_NONE)
     return override_value_ == OVERRIDE_ENABLED;
+  if (cached_value_ == NOT_CACHED)
+    cached_value_ = ComputeValue() ? CACHED_ENABLED : CACHED_DISABLED;
+  return cached_value_ == CACHED_ENABLED;
+}
 
+bool FeatureSwitch::ComputeValue() const {
   if (!switch_name_)
     return default_value_;
 
   std::string temp = command_line_->GetSwitchValueASCII(switch_name_);
   std::string switch_value;
   base::TrimWhitespaceASCII(temp, base::TRIM_ALL, &switch_value);
 
   if (switch_value == "1")
     return true;
 
@@ skipping 33 matching lines @@
 
 void FeatureSwitch::SetOverrideValue(OverrideValue override_value) {
   override_value_ = override_value;
 }
 
 FeatureSwitch::OverrideValue FeatureSwitch::GetOverrideValue() const {
   return override_value_;
 }
 
 }  // namespace extensions