Add Blink setting to block doc.written scripts on 2g-like networks

components/test_runner/test_runner.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 "components/test_runner/test_runner.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 194 matching lines @@
   void SetColorProfile(const std::string& name,
                        v8::Local<v8::Function> callback);
   void SetCustomPolicyDelegate(gin::Arguments* args);
   void SetCustomTextOutput(const std::string& output);
   void SetDatabaseQuota(int quota);
   void SetDisallowedSubresourcePathSuffixes(
       const std::vector<std::string>& suffixes);
   void SetDomainRelaxationForbiddenForURLScheme(bool forbidden,
                                                 const std::string& scheme);
   void SetDumpConsoleMessages(bool value);
+  void SetEffectiveConnectionType(const std::string& connection_type);
   void SetMockSpellCheckerEnabled(bool enabled);
   void SetImagesAllowed(bool allowed);
   void SetIsolatedWorldContentSecurityPolicy(int world_id,
                                              const std::string& policy);
   void SetIsolatedWorldSecurityOrigin(int world_id,
                                       v8::Local<v8::Value> origin);
   void SetJavaScriptCanAccessClipboard(bool can_access);
   void SetMIDIAccessorResult(bool result);
   void SetMockDeviceLight(double value);
   void SetMockDeviceMotion(gin::Arguments* args);
@@ skipping 279 matching lines @@
       .SetMethod("setColorProfile", &TestRunnerBindings::SetColorProfile)
       .SetMethod("setCustomPolicyDelegate",
                  &TestRunnerBindings::SetCustomPolicyDelegate)
       .SetMethod("setCustomTextOutput",
                  &TestRunnerBindings::SetCustomTextOutput)
       .SetMethod("setDatabaseQuota", &TestRunnerBindings::SetDatabaseQuota)
       .SetMethod("setDomainRelaxationForbiddenForURLScheme",
                  &TestRunnerBindings::SetDomainRelaxationForbiddenForURLScheme)
       .SetMethod("setDumpConsoleMessages",
                  &TestRunnerBindings::SetDumpConsoleMessages)
+      .SetMethod("setEffectiveConnectionType",
+                 &TestRunnerBindings::SetEffectiveConnectionType)
       .SetMethod("setMockSpellCheckerEnabled",
                  &TestRunnerBindings::SetMockSpellCheckerEnabled)
       .SetMethod("setIconDatabaseEnabled", &TestRunnerBindings::NotImplemented)
       .SetMethod("setImagesAllowed", &TestRunnerBindings::SetImagesAllowed)
       .SetMethod("setIsolatedWorldContentSecurityPolicy",
                  &TestRunnerBindings::SetIsolatedWorldContentSecurityPolicy)
       .SetMethod("setIsolatedWorldSecurityOrigin",
                  &TestRunnerBindings::SetIsolatedWorldSecurityOrigin)
       .SetMethod("setJavaScriptCanAccessClipboard",
                  &TestRunnerBindings::SetJavaScriptCanAccessClipboard)
@@ skipping 173 matching lines @@
     bool forbidden, const std::string& scheme) {
   if (view_runner_)
     view_runner_->SetDomainRelaxationForbiddenForURLScheme(forbidden, scheme);
 }
 
 void TestRunnerBindings::SetDumpConsoleMessages(bool enabled) {
   if (runner_)
     runner_->SetDumpConsoleMessages(enabled);
 }
 
+void TestRunnerBindings::SetEffectiveConnectionType(
+    const std::string& connection_type) {
+  blink::WebEffectiveConnectionType web_type =
+      blink::WebEffectiveConnectionType::TypeUnknown;
+  if (connection_type == "TypeUnknown")
+    web_type = blink::WebEffectiveConnectionType::TypeUnknown;
+  else if (connection_type == "TypeOffline")
+    web_type = blink::WebEffectiveConnectionType::TypeOffline;
+  else if (connection_type == "TypeSlow2G")
+    web_type = blink::WebEffectiveConnectionType::TypeSlow2G;
+  else if (connection_type == "Type2G")
+    web_type = blink::WebEffectiveConnectionType::Type2G;
+  else if (connection_type == "Type3G")
+    web_type = blink::WebEffectiveConnectionType::Type3G;
+  else if (connection_type == "Type4G")
+    web_type = blink::WebEffectiveConnectionType::Type4G;
+  else
+    NOTREACHED();
+
+  if (runner_)
+    runner_->SetEffectiveConnectionType(web_type);
+}
+
 void TestRunnerBindings::SetMockSpellCheckerEnabled(bool enabled) {
   if (runner_)
     runner_->SetMockSpellCheckerEnabled(enabled);
 }
 
 v8::Local<v8::Value>
 TestRunnerBindings::EvaluateScriptInIsolatedWorldAndReturnValue(
     int world_id, const std::string& script) {
   if (!view_runner_ || world_id <= 0 || world_id >= (1 << 29))
     return v8::Local<v8::Value>();
@@ skipping 829 matching lines @@
       main_view_(nullptr),
       mock_content_settings_client_(
           new MockContentSettingsClient(&layout_test_runtime_flags_)),
       will_navigate_(false),
       credential_manager_client_(new MockCredentialManagerClient),
       mock_screen_orientation_client_(new MockScreenOrientationClient),
       spellcheck_(new SpellCheckClient(this)),
       chooser_count_(0),
       previously_focused_view_(nullptr),
       is_web_platform_tests_mode_(false),
+      effective_connection_type_(
+          blink::WebEffectiveConnectionType::TypeUnknown),
       weak_factory_(this) {}
 
 TestRunner::~TestRunner() {}
 
 void TestRunner::Install(
     WebLocalFrame* frame,
     base::WeakPtr<TestRunnerForSpecificView> view_test_runner) {
   TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), view_test_runner,
                               frame);
 }
@@ skipping 991 matching lines @@
 void TestRunner::DumpNavigationPolicy() {
   layout_test_runtime_flags_.set_dump_navigation_policy(true);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 void TestRunner::SetDumpConsoleMessages(bool value) {
   layout_test_runtime_flags_.set_dump_console_messages(value);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
+void TestRunner::SetEffectiveConnectionType(
+    blink::WebEffectiveConnectionType connection_type) {
+  effective_connection_type_ = connection_type;
+}
+
 void TestRunner::SetMockSpellCheckerEnabled(bool enabled) {
   spellcheck_->SetEnabled(enabled);
 }
 
 bool TestRunner::ShouldDumpConsoleMessages() const {
   return layout_test_runtime_flags_.dump_console_messages();
 }
 
 void TestRunner::CloseWebInspector() {
   delegate_->CloseDevTools();
@@ skipping 148 matching lines @@
 
 void TestRunner::NotifyDone() {
   if (layout_test_runtime_flags_.wait_until_done() && !topLoadingFrame() &&
       !will_navigate_ && work_queue_.is_empty())
     delegate_->TestFinished();
   layout_test_runtime_flags_.set_wait_until_done(false);
   OnLayoutTestRuntimeFlagsChanged();
 }
 
 }  // namespace test_runner