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/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/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"
 
 namespace chromeos {
 
 namespace {
 
 const char kWebstoreDomain[] = "cws.com";
 
@@ skipping 20 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 73 matching lines @@
     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 {
     InProcessBrowserTest::SetUpCommandLine(command_line);
 
     // 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);
@@ skipping 25 matching lines @@
     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:
+  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");
   EXPECT_EQ("fake_app_1,fake_app_2", GetAppIds());
@@ skipping 32 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