Adds a field trial to control Web API kill switches.

chrome/browser/permissions/permission_context_base_unittest.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 "chrome/browser/permissions/permission_context_base.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/metrics/field_trial.h"
+#include "base/test/mock_entropy_provider.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/infobars/infobar_service.h"
+#include "chrome/browser/permissions/permission_context_uma_util.h"
 #include "chrome/browser/permissions/permission_queue_controller.h"
 #include "chrome/browser/permissions/permission_request_id.h"
 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/web_contents_tester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+static const char* kApiKillSwitchFieldStudy =
+    PermissionContextBase::kApiKillSwitchFieldStudy;
+static const char* kApiKillSwitchFieldParamBlockedValue =
+    PermissionContextBase::kApiKillSwitchFieldParamBlockedValue;
+static const char kApiKillSwitchTestGroup[] = "TestGroup";
+
 class TestPermissionContext : public PermissionContextBase {
  public:
   TestPermissionContext(Profile* profile,
                   const ContentSettingsType permission_type)
    : PermissionContextBase(profile, permission_type),
      permission_set_(false),
      permission_granted_(false),
-     tab_context_updated_(false) {}
+     tab_context_updated_(false),
+     field_trial_list_(new base::FieldTrialList(new base::MockEntropyProvider))
+     {}
 
   ~TestPermissionContext() override {}
 
   PermissionQueueController* GetInfoBarController() {
     return GetQueueController();
   }
 
   bool permission_granted() {
     return permission_granted_;
   }
 
   bool permission_set() {
     return permission_set_;
   }
 
   bool tab_context_updated() {
     return tab_context_updated_;
   }
 
   void TrackPermissionDecision(ContentSetting content_setting) {
     permission_set_ = true;
     permission_granted_ = content_setting == CONTENT_SETTING_ALLOW;
   }
 
+  void ResetFieldTrialList() {
+    // Destroy the existing FieldTrialList before creating a new one to avoid
+    // a DCHECK.
+    field_trial_list_.reset();
+    field_trial_list_.reset(new base::FieldTrialList(
+        new base::MockEntropyProvider));
+    variations::testing::ClearAllVariationParams();
+  }
+
  protected:
   void UpdateTabContext(const PermissionRequestID& id,
                         const GURL& requesting_origin,
                         bool allowed) override {
     tab_context_updated_ = true;
   }
 
   bool IsRestrictedToSecureOrigins() const override {
     return false;
   }
 
  private:
    bool permission_set_;
    bool permission_granted_;
    bool tab_context_updated_;
+   scoped_ptr<base::FieldTrialList> field_trial_list_;
 };
 
 class PermissionContextBaseTests : public ChromeRenderViewHostTestHarness {
  protected:
   PermissionContextBaseTests() {}
 
   // Accept or dismiss the permission bubble or infobar.
   void RespondToPermission(TestPermissionContext* context,
                            const PermissionRequestID& id,
                            const GURL& url,
@@ skipping 137 matching lines @@
             ->GetContentSetting(url.GetOrigin(),
                                 url.GetOrigin(),
                                 type,
                                 std::string());
     ContentSetting default_setting =
         HostContentSettingsMapFactory::GetForProfile(profile())
             ->GetDefaultContentSetting(type, nullptr);
     EXPECT_EQ(default_setting, setting_after_reset);
   }
 
+  void TestGlobalApiKillSwitch(ContentSettingsType type) {
+    TestPermissionContext permission_context(
+        profile(), type);
+    permission_context.ResetFieldTrialList();
+
+    EXPECT_FALSE(permission_context.IsApiKillSwitchOn());
+    std::map<std::string, std::string> params;
+    params[PermissionContextUmaUtil::GetPermissionString(type)] =
+        kApiKillSwitchFieldParamBlockedValue;
+    variations::AssociateVariationParams(
+        kApiKillSwitchFieldStudy, kApiKillSwitchTestGroup, params);
+    base::FieldTrialList::CreateFieldTrial(kApiKillSwitchFieldStudy,
+                                           kApiKillSwitchTestGroup);
+    EXPECT_TRUE(permission_context.IsApiKillSwitchOn());
+  }
+
  private:
   // ChromeRenderViewHostTestHarness:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     InfoBarService::CreateForWebContents(web_contents());
     PermissionBubbleManager::CreateForWebContents(web_contents());
   }
 
   DISALLOW_COPY_AND_ASSIGN(PermissionContextBaseTests);
 };
@@ skipping 50 matching lines @@
 #if defined(ENABLE_NOTIFICATIONS)
   TestGrantAndRevoke_TestContent(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                  CONTENT_SETTING_ASK);
 #endif
   TestGrantAndRevoke_TestContent(CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
                                  CONTENT_SETTING_ASK);
   TestGrantAndRevoke_TestContent(CONTENT_SETTINGS_TYPE_PUSH_MESSAGING,
                                  CONTENT_SETTING_ASK);
 }
 #endif
+
+// Tests the global kill switch by enabling/disabling the Field Trials.
+TEST_F(PermissionContextBaseTests, TestGlobalKillSwitch) {
+  TestGlobalApiKillSwitch(CONTENT_SETTINGS_TYPE_GEOLOCATION);
+  TestGlobalApiKillSwitch(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
+  TestGlobalApiKillSwitch(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
+  TestGlobalApiKillSwitch(CONTENT_SETTINGS_TYPE_PUSH_MESSAGING);
+  TestGlobalApiKillSwitch(CONTENT_SETTINGS_TYPE_DURABLE_STORAGE);
+#if defined(OS_ANDROID) || defined(OS_CHROMEOS)
+  TestGlobalApiKillSwitch(CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER);
+#endif
+  TestGlobalApiKillSwitch(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
+  TestGlobalApiKillSwitch(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
+}