Merge 244632 "kiosk: Do update check during launch."

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/at_exit.h"
 #include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/files/scoped_temp_dir.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/kiosk_app_manager_observer.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
+#include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension.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 "net/base/host_port_pair.h"
 #include "net/dns/mock_host_resolver.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
 
 namespace chromeos {
 
 namespace {
 
 const char kWebstoreDomain[] = "cws.com";
 
 // Helper KioskAppManager::GetConsumerKioskModeStatusCallback implementation.
 void ConsumerKioskModeStatusCheck(
     KioskAppManager::ConsumerKioskModeStatus* out_status,
@@ skipping 17 matching lines @@
 // Helper EnterpriseInstallAttributes::LockResultCallback implementation.
 void OnEnterpriseDeviceLock(
     policy::EnterpriseInstallAttributes::LockResult* out_locked,
     const base::Closure& runner_quit_task,
     policy::EnterpriseInstallAttributes::LockResult in_locked) {
   LOG(INFO) << "Enterprise lock  = " << in_locked;
   *out_locked = in_locked;
   runner_quit_task.Run();
 }
 
+scoped_refptr<extensions::Extension> MakeApp(const std::string& name,
+                                             const std::string& version,
+                                             const std::string& url,
+                                             const std::string& id) {
+  std::string err;
+  base::DictionaryValue value;
+  value.SetString("name", name);
+  value.SetString("version", version);
+  value.SetString("app.launch.web_url", url);
+  scoped_refptr<extensions::Extension> app =
+      extensions::Extension::Create(
+          base::FilePath(),
+          extensions::Manifest::INTERNAL,
+          value,
+          extensions::Extension::WAS_INSTALLED_BY_DEFAULT,
+          id,
+          &err);
+  EXPECT_EQ(err, "");
+  return app;
+}
+
 class TestKioskAppManagerObserver : public KioskAppManagerObserver {
  public:
   explicit TestKioskAppManagerObserver(KioskAppManager* manager)
       : manager_(manager),
         data_changed_count_(0),
         load_failure_count_(0) {
     manager_->AddObserver(this);
   }
   virtual ~TestKioskAppManagerObserver() {
     manager_->RemoveObserver(this);
@@ skipping 21 matching lines @@
   int load_failure_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestKioskAppManagerObserver);
 };
 
 class AppDataLoadWaiter : public KioskAppManagerObserver {
  public:
   explicit AppDataLoadWaiter(KioskAppManager* manager)
       : manager_(manager),
         loaded_(false) {
-    manager_->AddObserver(this);
   }
   virtual ~AppDataLoadWaiter() {
+  }
+
+  void Wait() {
+    manager_->AddObserver(this);
+    runner_ = new content::MessageLoopRunner;
+    runner_->Run();
     manager_->RemoveObserver(this);
   }
 
-  void Wait() {
-    base::MessageLoop::current()->Run();
-  }
-
   bool loaded() const { return loaded_; }
 
  private:
   // KioskAppManagerObserver overrides:
   virtual void OnKioskAppDataChanged(const std::string& app_id) OVERRIDE {
     loaded_ = true;
     base::MessageLoop::current()->Quit();
   }
   virtual void OnKioskAppDataLoadFailure(const std::string& app_id) OVERRIDE {
     loaded_ = false;
     base::MessageLoop::current()->Quit();
   }
 
+  scoped_refptr<content::MessageLoopRunner> runner_;
   KioskAppManager* manager_;
   bool loaded_;
 
   DISALLOW_COPY_AND_ASSIGN(AppDataLoadWaiter);
 };
 
 }  // namespace
 
 class KioskAppManagerTest : public InProcessBrowserTest {
  public:
   KioskAppManagerTest() {}
   virtual ~KioskAppManagerTest() {}
 
   // InProcessBrowserTest overrides:
+  virtual void SetUp() OVERRIDE {
+    base::FilePath test_data_dir;
+    PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
+    base::FilePath webstore_dir =
+        test_data_dir.Append(FILE_PATH_LITERAL("chromeos/app_mode/"));
+    embedded_test_server()->ServeFilesFromDirectory(webstore_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();
+  }
+
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
-    // We start the test server now instead of in
-    // SetUpInProcessBrowserTestFixture so that we can get its port number.
-    ASSERT_TRUE(test_server()->Start());
+    InProcessBrowserTest::SetUpCommandLine(command_line);
 
-    net::HostPortPair host_port = test_server()->host_port_pair();
-    test_gallery_url_ = base::StringPrintf(
-        "http://%s:%d/files/chromeos/app_mode/webstore",
-        kWebstoreDomain, host_port.port());
+    // Get fake webstore gallery URL. At the end, it should look something like
+    // http://cws.com:<test_server_port>/webstore.
+    const GURL& server_url = embedded_test_server()->base_url();
+    std::string google_host(kWebstoreDomain);
+    GURL::Replacements replace_google_host;
+    replace_google_host.SetHostStr(google_host);
+    GURL google_url = server_url.ReplaceComponents(replace_google_host);
+    GURL fake_store_url = google_url.Resolve("/webstore");
+    command_line->AppendSwitchASCII(switches::kAppsGalleryURL,
+                                    fake_store_url.spec());
+  }
 
-    command_line->AppendSwitchASCII(
-        switches::kAppsGalleryURL, test_gallery_url_);
+  virtual void SetUpOnMainThread() OVERRIDE {
+    InProcessBrowserTest::SetUpOnMainThread();
+
+    // Restart the thread as the sandbox host process has already been spawned.
+    // embedded_test_server()->RestartThreadAndListen();
   }
+
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+    InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
+
     host_resolver()->AddRule(kWebstoreDomain, "127.0.0.1");
   }
 
   std::string GetAppIds() const {
     KioskAppManager::Apps apps;
     manager()->GetApps(&apps);
 
     std::string str;
     for (size_t i = 0; i < apps.size(); ++i) {
       if (i > 0)
         str += ',';
       str += apps[i].app_id;
     }
 
     return str;
   }
 
-  KioskAppManager* manager() const { return KioskAppManager::Get(); }
-
   // Locks device for enterprise.
   policy::EnterpriseInstallAttributes::LockResult LockDeviceForEnterprise() {
     scoped_ptr<policy::EnterpriseInstallAttributes::LockResult> lock_result(
         new policy::EnterpriseInstallAttributes::LockResult(
             policy::EnterpriseInstallAttributes::LOCK_NOT_READY));
     scoped_refptr<content::MessageLoopRunner> runner =
         new content::MessageLoopRunner;
     g_browser_process->browser_policy_connector()->GetInstallAttributes()->
         LockDevice(
             "user@domain.com",
             policy::DEVICE_MODE_ENTERPRISE,
             "device-id",
             base::Bind(&OnEnterpriseDeviceLock,
                        lock_result.get(),
                        runner->QuitClosure()));
     runner->Run();
     return *lock_result.get();
   }
 
+  void SetExistingApp(const std::string& app_id,
+                      const std::string& app_name,
+                      const std::string& icon_file_name) {
+    base::FilePath test_dir;
+    ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir));
+    base::FilePath data_dir = test_dir.AppendASCII("chromeos/app_mode/");
+
+    // Copy the icon file to temp dir for using because ClearAppData test
+    // deletes it.
+    base::FilePath icon_path = temp_dir_.path().AppendASCII(icon_file_name);
+    base::CopyFile(data_dir.AppendASCII(icon_file_name), icon_path);
+
+    scoped_ptr<base::DictionaryValue> apps_dict(new base::DictionaryValue);
+    apps_dict->SetString(app_id + ".name", app_name);
+    apps_dict->SetString(app_id + ".icon", icon_path.MaybeAsASCII());
+
+    PrefService* local_state = g_browser_process->local_state();
+    DictionaryPrefUpdate dict_update(local_state,
+                                     KioskAppManager::kKioskDictionaryName);
+    dict_update->Set(KioskAppManager::kKeyApps, apps_dict.release());
+
+    // Make the app appear in device settings.
+    base::ListValue device_local_accounts;
+    scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
+    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);
+  }
+
+  KioskAppManager* manager() const { return KioskAppManager::Get(); }
+
  private:
-  std::string test_gallery_url_;
-  base::ShadowingAtExitManager exit_manager_;
+  base::ScopedTempDir temp_dir_;
 
   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");
@@ skipping 33 matching lines @@
   manager()->SetAutoLaunchApp("none_exist_app");
   EXPECT_EQ("", manager()->GetAutoLaunchApp());
   EXPECT_FALSE(manager()->IsAutoLaunchEnabled());
 
   // Add an existing app again.
   manager()->AddApp("fake_app_1");
   EXPECT_EQ("fake_app_1", GetAppIds());
 }
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, LoadCached) {
-  base::FilePath test_dir;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir));
-  base::FilePath data_dir = test_dir.AppendASCII("chromeos/app_mode/");
-
-  scoped_ptr<base::DictionaryValue> apps_dict(new base::DictionaryValue);
-  apps_dict->SetString("app_1.name", "App1 Name");
-  std::string icon_path =
-      base::StringPrintf("%s/red16x16.png", data_dir.value().c_str());
-  apps_dict->SetString("app_1.icon", icon_path);
-
-  PrefService* local_state = g_browser_process->local_state();
-  DictionaryPrefUpdate dict_update(local_state,
-                                   KioskAppManager::kKioskDictionaryName);
-  dict_update->Set(KioskAppManager::kKeyApps, apps_dict.release());
-
-  // Make the app appear in device settings.
-  base::ListValue device_local_accounts;
-  scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
-  entry->SetStringWithoutPathExpansion(
-      kAccountsPrefDeviceLocalAccountsKeyId,
-      "app_1_id");
-  entry->SetIntegerWithoutPathExpansion(
-      kAccountsPrefDeviceLocalAccountsKeyType,
-      policy::DeviceLocalAccount::TYPE_KIOSK_APP);
-  entry->SetStringWithoutPathExpansion(
-      kAccountsPrefDeviceLocalAccountsKeyKioskAppId,
-      "app_1");
-  device_local_accounts.Append(entry.release());
-  CrosSettings::Get()->Set(kAccountsPrefDeviceLocalAccounts,
-                           device_local_accounts);
+  SetExistingApp("app_1", "Cached App1 Name", "red16x16.png");
 
   AppDataLoadWaiter waiter(manager());
   waiter.Wait();
   EXPECT_TRUE(waiter.loaded());
+
+  KioskAppManager::Apps apps;
+  manager()->GetApps(&apps);
+  EXPECT_EQ(1u, apps.size());
+  EXPECT_EQ("app_1", apps[0].app_id);
+  EXPECT_EQ("Cached App1 Name", apps[0].name);
+  EXPECT_EQ(gfx::Size(16, 16), apps[0].icon.size());
+}
+
+IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, ClearAppData) {
+  SetExistingApp("app_1", "Cached App1 Name", "red16x16.png");
+
+  PrefService* local_state = g_browser_process->local_state();
+  const base::DictionaryValue* dict =
+      local_state->GetDictionary(KioskAppManager::kKioskDictionaryName);
+  const base::DictionaryValue* apps_dict;
+  EXPECT_TRUE(dict->GetDictionary(KioskAppManager::kKeyApps, &apps_dict));
+  EXPECT_TRUE(apps_dict->HasKey("app_1"));
+
+  manager()->ClearAppData("app_1");
+
+  EXPECT_FALSE(apps_dict->HasKey("app_1"));
+}
+
+IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, UpdateAppDataFromProfile) {
+  SetExistingApp("app_1", "Cached App1 Name", "red16x16.png");
+
+  AppDataLoadWaiter waiter(manager());
+  waiter.Wait();
+  EXPECT_TRUE(waiter.loaded());
 
   KioskAppManager::Apps apps;
   manager()->GetApps(&apps);
   EXPECT_EQ(1u, apps.size());
   EXPECT_EQ("app_1", apps[0].app_id);
-  EXPECT_EQ("App1 Name", apps[0].name);
-  EXPECT_EQ(gfx::Size(16, 16), apps[0].icon.size());
+  EXPECT_EQ("Cached App1 Name", apps[0].name);
+
+  scoped_refptr<extensions::Extension> updated_app =
+      MakeApp("Updated App1 Name", "2.0", "http://localhost/", "app_1");
+  manager()->UpdateAppDataFromProfile(
+      "app_1", browser()->profile(), updated_app.get());
+
+  waiter.Wait();
+  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) {
   manager()->AddApp("unknown_app");
 
   TestKioskAppManagerObserver observer(manager());
 
   AppDataLoadWaiter waiter(manager());
   waiter.Wait();
   EXPECT_FALSE(waiter.loaded());
@@ skipping 106 matching lines @@
       new content::MessageLoopRunner;
   manager()->GetConsumerKioskModeStatus(
       base::Bind(&ConsumerKioskModeStatusCheck,
                  status.get(),
                  runner3->QuitClosure()));
   runner3->Run();
   EXPECT_EQ(*status.get(), KioskAppManager::CONSUMER_KIOSK_MODE_DISABLED);
 }
 
 }  // namespace chromeos