Revert of Re-enable fetching component policies for login screen apps

chrome/browser/chromeos/policy/device_cloud_policy_browsertest.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 <memory>
 
 #include "base/command_line.h"
 #include "base/files/dir_reader_posix.h"
 #include "base/files/file_path.h"
 #include "base/memory/ptr_util.h"
@@ skipping 68 matching lines @@
   EXPECT_TRUE(connector->GetDeviceCloudPolicyInitializer());
 }
 
 // This class is the base class for the tests of the behavior regarding
 // extensions installed on the signin screen (which is generally possible only
 // through an admin policy, but the tests may install the extensions directly
 // for the test purposes).
 class SigninExtensionsDeviceCloudPolicyBrowserTestBase
     : public DevicePolicyCrosBrowserTest {
  protected:
-  static constexpr const char* kTestExtensionId =
+  constexpr static const char* kTestExtensionId =
       "baogpbmpccplckhhehfipokjaflkmbno";
-  static constexpr const char* kTestExtensionSourceDir =
+  constexpr static const char* kTestExtensionSourceDir =
       "extensions/signin_screen_managed_storage";
-  static constexpr const char* kTestExtensionVersion = "1.0";
-  static constexpr const char* kTestExtensionTestPage = "test.html";
-  static constexpr const char* kFakePolicyUrl =
+  constexpr static const char* kTestExtensionVersion = "1.0";
+  constexpr static const char* kTestExtensionTestPage = "test.html";
+  constexpr static const char* kFakePolicyUrl =
       "http://example.org/test-policy.json";
-  static constexpr const char* kFakePolicy =
+  constexpr static const char* kFakePolicy =
       "{\"string-policy\": {\"Value\": \"value\"}}";
-  static constexpr int kFakePolicyPublicKeyVersion = 1;
-  static constexpr const char* kPolicyProtoCacheKey = "signinextension-policy";
-  static constexpr const char* kPolicyDataCacheKey =
+  constexpr static const char* kPolicyProtoCacheKey = "signinextension-policy";
+  constexpr static const char* kPolicyDataCacheKey =
       "signinextension-policy-data";
 
   SigninExtensionsDeviceCloudPolicyBrowserTestBase() {}
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     DevicePolicyCrosBrowserTest::SetUpCommandLine(command_line);
     command_line->AppendSwitch(chromeos::switches::kLoginManager);
     command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
     // This flag is required for the successful installation of the test
     // extension into the signin profile, due to some checks in
@@ skipping 37 matching lines @@
 
   static const extensions::Extension* GetTestExtension() {
     extensions::ExtensionRegistry* registry =
         extensions::ExtensionRegistry::Get(GetSigninProfile());
     const extensions::Extension* extension =
         registry->enabled_extensions().GetByID(kTestExtensionId);
     EXPECT_TRUE(extension);
     return extension;
   }
 
-  static enterprise_management::PolicyFetchResponse BuildTestComponentPolicy() {
+  enterprise_management::PolicyFetchResponse BuildTestComponentPolicy() {
     ComponentPolicyBuilder builder;
     MakeTestComponentPolicyBuilder(&builder);
     return builder.policy();
   }
 
-  static enterprise_management::ExternalPolicyData
-  BuildTestComponentPolicyPayload() {
+  enterprise_management::ExternalPolicyData BuildTestComponentPolicyPayload() {
     ComponentPolicyBuilder builder;
     MakeTestComponentPolicyBuilder(&builder);
     return builder.payload();
   }
 
  private:
   void SetFakeDevicePolicy() {
     device_policy()->policy_data().set_username(PolicyBuilder::kFakeUsername);
-    device_policy()->policy_data().set_public_key_version(
-        kFakePolicyPublicKeyVersion);
+    device_policy()->SetDefaultSigningKey();
     device_policy()->Build();
     session_manager_client()->set_device_policy(device_policy()->GetBlob());
   }
 
-  static void MakeTestComponentPolicyBuilder(ComponentPolicyBuilder* builder) {
+  void MakeTestComponentPolicyBuilder(ComponentPolicyBuilder* builder) {
     builder->policy_data().set_policy_type(
         dm_protocol::kChromeSigninExtensionPolicyType);
-    builder->policy_data().set_username(PolicyBuilder::kFakeUsername);
+    builder->policy_data().set_username(
+        device_policy()->policy_data().username());
     builder->policy_data().set_settings_entity_id(kTestExtensionId);
-    builder->policy_data().set_public_key_version(kFakePolicyPublicKeyVersion);
+    builder->policy_data().set_public_key_version(1);
     builder->payload().set_download_url(kFakePolicyUrl);
     builder->payload().set_secure_hash(crypto::SHA256HashString(kFakePolicy));
+    builder->SetDefaultSigningKey();
     builder->Build();
   }
 
   DISALLOW_COPY_AND_ASSIGN(SigninExtensionsDeviceCloudPolicyBrowserTestBase);
 };
 
 // This class tests whether the component policy is successfully processed and
 // passed to the extension that is installed into the signin profile after the
 // initialization finishes.
 //
@@ skipping 73 matching lines @@
                                      net::URLRequestStatus::SUCCESS);
   }
 
   LocalPolicyTestServer policy_test_server_;
   net::URLFetcherImplFactory fetcher_impl_factory_;
   net::FakeURLFetcherFactory fetcher_factory_;
   base::FilePath component_policy_cache_dir_;
   std::unique_ptr<base::AutoReset<bool>> signin_policy_provided_disabler_;
 };
 
+// DISABLED: see crbug.com/666720, crbug.com/644304. TODO(emaxx): Enable the
+// test back.
 IN_PROC_BROWSER_TEST_F(SigninExtensionsDeviceCloudPolicyBrowserTest,
-                       InstallAndRunInWindow) {
+                       DISABLED_InstallAndRunInWindow) {
   const extensions::Extension* extension = InstallAndLoadTestExtension();
   ASSERT_TRUE(extension);
   Browser* browser = CreateBrowser(GetSigninProfile());
   extensions::ResultCatcher result_catcher;
   ui_test_utils::NavigateToURL(
       browser, extension->GetResourceURL(kTestExtensionTestPage));
   EXPECT_TRUE(result_catcher.GetNextResult());
   CloseBrowserSynchronously(browser);
 }
 
 // This class tests that the cached component policy is successfully loaded and
 // passed to the extension that is already installed into the signin profile.
 //
 // To accomplish this, the class prefills the signin profile with, first, the
 // installed test extension, and, second, with the cached component policy.
 class PreinstalledSigninExtensionsDeviceCloudPolicyBrowserTest
     : public SigninExtensionsDeviceCloudPolicyBrowserTestBase {
  protected:
-  static constexpr const char* kFakeProfileSourceDir =
+  constexpr static const char* kFakeProfileSourceDir =
       "extensions/profiles/signin_screen_managed_storage";
 
+  std::unique_ptr<base::AutoReset<bool>> signin_policy_provided_disabler_;
+
   bool SetUpUserDataDirectory() override {
     PrefillSigninProfile();
     PrefillComponentPolicyCache();
     return DevicePolicyCrosBrowserTest::SetUpUserDataDirectory();
   }
 
   void SetUpInProcessBrowserTestFixture() override {
     SigninExtensionsDeviceCloudPolicyBrowserTestBase::
         SetUpInProcessBrowserTestFixture();
     signin_policy_provided_disabler_ =
         chromeos::GetScopedSigninScreenPolicyProviderDisablerForTesting();
   }
 
- private:
   static void PrefillSigninProfile() {
     base::FilePath profile_source_path;
     EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &profile_source_path));
     profile_source_path = profile_source_path.AppendASCII(kFakeProfileSourceDir)
                               .AppendASCII(chrome::kInitialProfile);
 
     base::FilePath profile_target_path;
     EXPECT_TRUE(PathService::Get(chrome::DIR_USER_DATA, &profile_target_path));
 
     EXPECT_TRUE(
@@ skipping 16 matching lines @@
     base::FilePath cache_dir;
     EXPECT_TRUE(PathService::Get(chromeos::DIR_SIGNIN_PROFILE_COMPONENT_POLICY,
                                  &cache_dir));
 
     ResourceCache cache(cache_dir, new base::NullTaskRunner);
     EXPECT_TRUE(cache.Store(kPolicyProtoCacheKey, kTestExtensionId,
                             BuildTestComponentPolicy().SerializeAsString()));
     EXPECT_TRUE(
         cache.Store(kPolicyDataCacheKey, kTestExtensionId, kFakePolicy));
   }
-
-  std::unique_ptr<base::AutoReset<bool>> signin_policy_provided_disabler_;
 };
 
+// DISABLED: see crbug.com/666720, crbug.com/644304. TODO(emaxx): Enable the
+// test back.
 IN_PROC_BROWSER_TEST_F(PreinstalledSigninExtensionsDeviceCloudPolicyBrowserTest,
-                       OfflineStart) {
+                       DISABLED_OfflineStart) {
   const extensions::Extension* extension = GetTestExtension();
   ASSERT_TRUE(extension);
   Browser* browser = CreateBrowser(GetSigninProfile());
   extensions::ResultCatcher result_catcher;
   ui_test_utils::NavigateToURL(
       browser, extension->GetResourceURL(kTestExtensionTestPage));
   EXPECT_TRUE(result_catcher.GetNextResult());
   CloseBrowserSynchronously(browser);
 }
 
 }  // namespace policy