Switch to direct use of OwnerSettingsServiceChromeOS::Set() in tests.

chrome/browser/chromeos/app_mode/kiosk_app_manager_browsertest.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 "chrome/browser/chromeos/app_mode/kiosk_app_manager.h"
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/app_mode/fake_cws.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager_observer.h"
+#include "chrome/browser/chromeos/ownership/fake_owner_settings_service.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
-#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/common/extension.h"
 #include "net/base/host_port_pair.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
@@ skipping 127 matching lines @@
   int data_change_count_;
   int data_loaded_threshold_;
 
   DISALLOW_COPY_AND_ASSIGN(AppDataLoadWaiter);
 };
 
 }  // namespace
 
 class KioskAppManagerTest : public InProcessBrowserTest {
  public:
-  KioskAppManagerTest() : fake_cws_(new FakeCWS()) {}
+  KioskAppManagerTest() : settings_helper_(false), fake_cws_(new FakeCWS()) {}
   ~KioskAppManagerTest() override {}
 
   // InProcessBrowserTest overrides:
   void SetUp() override {
     base::FilePath test_data_dir;
     PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
     embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
     ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
     // Stop IO thread here because no threads are allowed while
     // spawning sandbox host process. See crbug.com/322732.
     embedded_test_server()->StopThread();
 
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     InProcessBrowserTest::SetUp();
   }
 
   void SetUpCommandLine(base::CommandLine* command_line) override {
     InProcessBrowserTest::SetUpCommandLine(command_line);
 
     // Initialize fake_cws_ to setup web store gallery.
     fake_cws_->Init(embedded_test_server());
   }
 
   void SetUpOnMainThread() override {
     InProcessBrowserTest::SetUpOnMainThread();
 
     // Restart the thread as the sandbox host process has already been spawned.
     embedded_test_server()->RestartThreadAndListen();
+
+    settings_helper_.ReplaceProvider(kAccountsPrefDeviceLocalAccounts);
+    owner_settings_service_.reset(
+        settings_helper_.CreateOwnerSettingsService(browser()->profile()));
   }
 
+  void TearDownOnMainThread() override { settings_helper_.RestoreProvider(); }
+
   void SetUpInProcessBrowserTestFixture() override {
     InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
 
     host_resolver()->AddRule("*", "127.0.0.1");
   }
 
   std::string GetAppIds() const {
     KioskAppManager::Apps apps;
     manager()->GetApps(&apps);
 
@@ skipping 53 matching lines @@
     entry->SetStringWithoutPathExpansion(
         kAccountsPrefDeviceLocalAccountsKeyId,
         app_id + "_id");
     entry->SetIntegerWithoutPathExpansion(
         kAccountsPrefDeviceLocalAccountsKeyType,
         policy::DeviceLocalAccount::TYPE_KIOSK_APP);
     entry->SetStringWithoutPathExpansion(
         kAccountsPrefDeviceLocalAccountsKeyKioskAppId,
         app_id);
     device_local_accounts.Append(entry.release());
-    CrosSettings::Get()->Set(kAccountsPrefDeviceLocalAccounts,
-                             device_local_accounts);
+    owner_settings_service_->Set(kAccountsPrefDeviceLocalAccounts,
+                                 device_local_accounts);
   }
 
   bool GetCachedCrx(const std::string& app_id,
                     base::FilePath* file_path,
                     std::string* version) {
     return manager()->GetCachedCrx(app_id, file_path, version);
   }
 
   void UpdateAppData() { manager()->UpdateAppData(); }
 
   void RunAddNewAppTest(const std::string& id,
                         const std::string& version,
                         const std::string& app_name) {
     std::string crx_file_name = id + ".crx";
     fake_cws_->SetUpdateCrx(id, crx_file_name, version);
 
     AppDataLoadWaiter waiter(manager(), 3);
-    manager()->AddApp(id);
+    manager()->AddApp(id, owner_settings_service_.get());
     waiter.Wait();
     EXPECT_TRUE(waiter.loaded());
 
     // Check CRX file is cached.
     base::FilePath crx_path;
     std::string crx_version;
     EXPECT_TRUE(GetCachedCrx(id, &crx_path, &crx_version));
     EXPECT_TRUE(base::PathExists(crx_path));
     EXPECT_EQ(version, crx_version);
     // Verify the original crx file is identical to the cached file.
@@ skipping 32 matching lines @@
     expected_icon_path =
         expected_icon_path.AppendASCII(KioskAppManager::kIconCacheDir)
             .AppendASCII(apps[0].app_id)
             .AddExtension(".png");
     EXPECT_EQ(expected_icon_path.value(), icon_path_string);
   }
 
   KioskAppManager* manager() const { return KioskAppManager::Get(); }
   FakeCWS* fake_cws() { return fake_cws_.get(); }
 
+ protected:
+  ScopedCrosSettingsTestHelper settings_helper_;
+  scoped_ptr<FakeOwnerSettingsService> owner_settings_service_;
+
  private:
   base::ScopedTempDir temp_dir_;
   scoped_ptr<FakeCWS> fake_cws_;
 
   DISALLOW_COPY_AND_ASSIGN(KioskAppManagerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, Basic) {
   // Add a couple of apps. Use "fake_app_x" that do not have data on the test
   // server to avoid pending data loads that could be lingering on tear down and
   // cause DCHECK failure in utility_process_host_impl.cc.
-  manager()->AddApp("fake_app_1");
-  manager()->AddApp("fake_app_2");
+  manager()->AddApp("fake_app_1", owner_settings_service_.get());
+  manager()->AddApp("fake_app_2", owner_settings_service_.get());
   EXPECT_EQ("fake_app_1,fake_app_2", GetAppIds());
 
   // Set an auto launch app.
-  manager()->SetAutoLaunchApp("fake_app_1");
+  manager()->SetAutoLaunchApp("fake_app_1", owner_settings_service_.get());
   EXPECT_EQ("fake_app_1", manager()->GetAutoLaunchApp());
 
   // Make sure that if an app was auto launched with zero delay, it is reflected
   // in the app data.
   KioskAppManager::App app;
   manager()->GetApp("fake_app_1", &app);
   EXPECT_FALSE(app.was_auto_launched_with_zero_delay);
 
   manager()->SetAppWasAutoLaunchedWithZeroDelay("fake_app_1");
   manager()->GetApp("fake_app_1", &app);
   EXPECT_TRUE(app.was_auto_launched_with_zero_delay);
 
   // Clear the auto launch app.
-  manager()->SetAutoLaunchApp("");
+  manager()->SetAutoLaunchApp("", owner_settings_service_.get());
   EXPECT_EQ("", manager()->GetAutoLaunchApp());
   EXPECT_FALSE(manager()->IsAutoLaunchEnabled());
 
   // App should still report it was auto launched with zero delay, even though
   // it is no longer set to auto launch in the future.
   manager()->GetApp("fake_app_1", &app);
   EXPECT_TRUE(app.was_auto_launched_with_zero_delay);
 
   // Set another auto launch app.
-  manager()->SetAutoLaunchApp("fake_app_2");
+  manager()->SetAutoLaunchApp("fake_app_2", owner_settings_service_.get());
   EXPECT_EQ("fake_app_2", manager()->GetAutoLaunchApp());
 
   // Check auto launch permissions.
   EXPECT_FALSE(manager()->IsAutoLaunchEnabled());
   manager()->SetEnableAutoLaunch(true);
   EXPECT_TRUE(manager()->IsAutoLaunchEnabled());
 
   // Remove the auto launch app.
-  manager()->RemoveApp("fake_app_2");
+  manager()->RemoveApp("fake_app_2", owner_settings_service_.get());
   EXPECT_EQ("fake_app_1", GetAppIds());
   EXPECT_EQ("", manager()->GetAutoLaunchApp());
 
   // Add the just removed auto launch app again and it should no longer be
   // the auto launch app.
-  manager()->AddApp("fake_app_2");
+  manager()->AddApp("fake_app_2", owner_settings_service_.get());
   EXPECT_EQ("", manager()->GetAutoLaunchApp());
-  manager()->RemoveApp("fake_app_2");
+  manager()->RemoveApp("fake_app_2", owner_settings_service_.get());
   EXPECT_EQ("fake_app_1", GetAppIds());
 
   // Set a none exist app as auto launch.
-  manager()->SetAutoLaunchApp("none_exist_app");
+  manager()->SetAutoLaunchApp("none_exist_app", owner_settings_service_.get());
   EXPECT_EQ("", manager()->GetAutoLaunchApp());
   EXPECT_FALSE(manager()->IsAutoLaunchEnabled());
 
   // Add an existing app again.
-  manager()->AddApp("fake_app_1");
+  manager()->AddApp("fake_app_1", owner_settings_service_.get());
   EXPECT_EQ("fake_app_1", GetAppIds());
 }
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, LoadCached) {
   SetExistingApp("app_1", "Cached App1 Name", "red16x16.png");
 
   fake_cws()->SetNoUpdate("app_1");
   AppDataLoadWaiter waiter(manager(), 1);
   waiter.Wait();
   EXPECT_TRUE(waiter.loaded());
@@ skipping 44 matching lines @@
   EXPECT_TRUE(waiter.loaded());
 
   manager()->GetApps(&apps);
   EXPECT_EQ(1u, apps.size());
   EXPECT_EQ("app_1", apps[0].app_id);
   EXPECT_EQ("Updated App1 Name", apps[0].name);
 }
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, BadApp) {
   AppDataLoadWaiter waiter(manager(), 2);
-  manager()->AddApp("unknown_app");
+  manager()->AddApp("unknown_app", owner_settings_service_.get());
   waiter.Wait();
   EXPECT_FALSE(waiter.loaded());
   EXPECT_EQ("", GetAppIds());
 }
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, GoodApp) {
   // Webstore data json is in
   //   chrome/test/data/chromeos/app_mode/webstore/inlineinstall/detail/app_1
   fake_cws()->SetNoUpdate("app_1");
   AppDataLoadWaiter waiter(manager(), 2);
-  manager()->AddApp("app_1");
+  manager()->AddApp("app_1", owner_settings_service_.get());
   waiter.Wait();
   EXPECT_TRUE(waiter.loaded());
 
   // Check data is correct.
   KioskAppManager::Apps apps;
   manager()->GetApps(&apps);
   ASSERT_EQ(1u, apps.size());
   EXPECT_EQ("app_1", apps[0].app_id);
   EXPECT_EQ("Name of App 1", apps[0].name);
   EXPECT_EQ(gfx::Size(16, 16), apps[0].icon.size());
@@ skipping 28 matching lines @@
   KioskAppManager::Apps apps;
   manager()->GetApps(&apps);
   ASSERT_EQ(1u, apps.size());
   base::FilePath crx_path;
   std::string version;
   EXPECT_TRUE(GetCachedCrx(kTestLocalFsKioskApp, &crx_path, &version));
   EXPECT_TRUE(base::PathExists(crx_path));
   EXPECT_EQ("1.0.0", version);
 
   // Remove the app now.
-  manager()->RemoveApp(kTestLocalFsKioskApp);
+  manager()->RemoveApp(kTestLocalFsKioskApp, owner_settings_service_.get());
   content::RunAllBlockingPoolTasksUntilIdle();
   manager()->GetApps(&apps);
   ASSERT_EQ(0u, apps.size());
   EXPECT_FALSE(base::PathExists(crx_path));
   EXPECT_FALSE(GetCachedCrx(kTestLocalFsKioskApp, &crx_path, &version));
 }
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, UpdateApp) {
   // Add a version 1 app first.
   RunAddNewAppTest(kTestLocalFsKioskApp, "1.0.0", kTestLocalFsKioskAppName);
@@ skipping 61 matching lines @@
   ASSERT_EQ(1u, apps.size());
   base::FilePath v2_crx_path;
   std::string new_version;
   EXPECT_TRUE(GetCachedCrx(kTestLocalFsKioskApp, &v2_crx_path, &new_version));
   EXPECT_EQ("2.0.0", new_version);
   // Verify both v1 and v2 crx files exist.
   EXPECT_TRUE(base::PathExists(v1_crx_path));
   EXPECT_TRUE(base::PathExists(v2_crx_path));
 
   // Remove the app now.
-  manager()->RemoveApp(kTestLocalFsKioskApp);
+  manager()->RemoveApp(kTestLocalFsKioskApp, owner_settings_service_.get());
   content::RunAllBlockingPoolTasksUntilIdle();
   manager()->GetApps(&apps);
   ASSERT_EQ(0u, apps.size());
   // Verify both v1 and v2 crx files are removed.
   EXPECT_FALSE(base::PathExists(v1_crx_path));
   EXPECT_FALSE(base::PathExists(v2_crx_path));
   EXPECT_FALSE(GetCachedCrx(kTestLocalFsKioskApp, &v2_crx_path, &version));
 }
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, EnableConsumerKiosk) {
@@ skipping 67 matching lines @@
   manager()->GetConsumerKioskAutoLaunchStatus(
       base::Bind(&ConsumerKioskAutoLaunchStatusCheck,
                  status.get(),
                  runner3->QuitClosure()));
   runner3->Run();
   EXPECT_EQ(*status.get(),
             KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_DISABLED);
 }
 
 }  // namespace chromeos