Revert 229896 "Cache force-installed apps/extensions in device-l..."

trunk/src/chrome/browser/chromeos/policy/device_local_account_browsertest.cc

 // Copyright (c) 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 <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
-#include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/test/scoped_path_override.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/existing_user_controller.h"
 #include "chrome/browser/chromeos/login/login_display_host.h"
 #include "chrome/browser/chromeos/login/login_display_host_impl.h"
 #include "chrome/browser/chromeos/login/mock_login_status_consumer.h"
 #include "chrome/browser/chromeos/login/screens/wizard_screen.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
@@ skipping 17 matching lines @@
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
-#include "chromeos/chromeos_paths.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_method_call_status.h"
 #include "chromeos/dbus/fake_session_manager_client.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/test/browser_test_utils.h"
@@ skipping 36 matching lines @@
     "<?xml version='1.0' encoding='UTF-8'?>\n"
     "<gupdate xmlns='http://www.google.com/update2/response' protocol='2.0'>\n";
 const char kUpdateManifestTemplate[] =
     "  <app appid='%s'>\n"
     "    <updatecheck codebase='%s' version='%s' />\n"
     "  </app>\n";
 const char kUpdateManifestFooter[] =
     "</gupdate>\n";
 const char kHostedAppID[] = "kbmnembihfiondgfjekmnmcbddelicoi";
 const char kHostedAppCRXPath[] = "extensions/hosted_app.crx";
-const char kHostedAppVersion[] = "1.0.0.0";
+const char kHostedAppVersion[] = "0.1";
 const char kGoodExtensionID[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
-const char kGoodExtensionCRXPath[] = "extensions/good.crx";
+const char kGoodExtensionPath[] = "extensions/good.crx";
 const char kGoodExtensionVersion[] = "1.0";
 
 // Helper that serves extension update manifests to Chrome.
 class TestingUpdateManifestProvider {
  public:
 
   // Update manifests will be served at |relative_update_url|.
   explicit TestingUpdateManifestProvider(
       const std::string& relative_update_url);
   ~TestingUpdateManifestProvider();
@@ skipping 111 matching lines @@
   virtual void SetUp() OVERRIDE {
     // Configure and start the test server.
     scoped_ptr<crypto::RSAPrivateKey> signing_key(
         PolicyBuilder::CreateTestSigningKey());
     ASSERT_TRUE(test_server_.SetSigningKey(signing_key.get()));
     signing_key.reset();
     test_server_.RegisterClient(PolicyBuilder::kFakeToken,
                                 PolicyBuilder::kFakeDeviceId);
     ASSERT_TRUE(test_server_.Start());
 
-    ASSERT_TRUE(extension_cache_root_dir_.CreateUniqueTempDir());
-    extension_cache_root_dir_override_.reset(new base::ScopedPathOverride(
-        chromeos::DIR_DEVICE_LOCAL_ACCOUNT_CACHE,
-        extension_cache_root_dir_.path()));
-
     DevicePolicyCrosBrowserTest::SetUp();
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
     command_line->AppendSwitch(chromeos::switches::kLoginManager);
     command_line->AppendSwitch(chromeos::switches::kForceLoginManagerInTests);
     command_line->AppendSwitchASCII(
         switches::kDeviceManagementUrl, test_server_.GetServiceURL().spec());
     command_line->AppendSwitchASCII(chromeos::switches::kLoginProfile, "user");
   }
@@ skipping 69 matching lines @@
                               std::string(), proto.SerializeAsString());
   }
 
   void CheckPublicSessionPresent(const std::string& id) {
     const chromeos::User* user = chromeos::UserManager::Get()->FindUser(id);
     ASSERT_TRUE(user);
     EXPECT_EQ(id, user->email());
     EXPECT_EQ(chromeos::User::USER_TYPE_PUBLIC_ACCOUNT, user->GetType());
   }
 
-  base::FilePath GetCacheDirectoryForAccountID(const std::string& account_id) {
-    return extension_cache_root_dir_.path()
-        .Append(base::HexEncode(account_id.c_str(), account_id.size()));
-  }
-
-  base::FilePath GetCacheCRXFile(const std::string& account_id,
-                                 const std::string& id,
-                                 const std::string& version) {
-    return GetCacheDirectoryForAccountID(account_id)
-        .Append(base::StringPrintf("%s-%s.crx", id.c_str(), version.c_str()));
-  }
-
   const std::string user_id_1_;
   const std::string user_id_2_;
 
-  base::ScopedTempDir extension_cache_root_dir_;
-  scoped_ptr<base::ScopedPathOverride> extension_cache_root_dir_override_;
-
   UserPolicyBuilder device_local_account_policy_;
   LocalPolicyTestServer test_server_;
 };
 
 static bool IsKnownUser(const std::string& account_id) {
   return chromeos::UserManager::Get()->IsKnownUser(account_id);
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, LoginScreen) {
   AddPublicSessionToDevicePolicy(kAccountId1);
@@ skipping 195 matching lines @@
   BrowserWindow* browser_window = browser->window();
   ASSERT_TRUE(browser_window);
   chrome::EndKeepAlive();
 
   // Verify that an attempt to enter fullscreen mode is denied.
   EXPECT_FALSE(browser_window->IsFullscreen());
   chrome::ToggleFullscreenMode(browser);
   EXPECT_FALSE(browser_window->IsFullscreen());
 }
 
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExtensionsUncached) {
+IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExtensionWhitelist) {
   // Make it possible to force-install a hosted app and an extension.
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   TestingUpdateManifestProvider testing_update_manifest_provider(
       kRelativeUpdateURL);
   testing_update_manifest_provider.AddUpdate(
       kHostedAppID,
       kHostedAppVersion,
       embedded_test_server()->GetURL(std::string("/") + kHostedAppCRXPath));
   testing_update_manifest_provider.AddUpdate(
       kGoodExtensionID,
       kGoodExtensionVersion,
-      embedded_test_server()->GetURL(std::string("/") + kGoodExtensionCRXPath));
+      embedded_test_server()->GetURL(std::string("/") + kGoodExtensionPath));
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&TestingUpdateManifestProvider::HandleRequest,
                  base::Unretained(&testing_update_manifest_provider)));
 
   // Specify policy to force-install the hosted app and the extension.
   em::StringList* forcelist = device_local_account_policy_.payload()
       .mutable_extensioninstallforcelist()->mutable_value();
   forcelist->add_entries(base::StringPrintf(
       "%s;%s",
       kHostedAppID,
@@ skipping 38 matching lines @@
       base::Bind(DoesInstallFailureReferToId, kGoodExtensionID));
 
   // Start login into the device-local account.
   host->StartSignInScreen();
   chromeos::ExistingUserController* controller =
       chromeos::ExistingUserController::current_controller();
   ASSERT_TRUE(controller);
   controller->LoginAsPublicAccount(user_id_1_);
 
   // Wait for the hosted app installation to succeed and the extension
-  // installation to fail (because hosted apps are whitelisted for use in
-  // device-local accounts and extensions are not).
-  hosted_app_observer.Wait();
-  extension_observer.Wait();
-
-  // Verify that the hosted app was installed.
-  Profile* profile = ProfileManager::GetDefaultProfile();
-  ASSERT_TRUE(profile);
-  ExtensionService* extension_service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  EXPECT_TRUE(extension_service->GetExtensionById(kHostedAppID, true));
-
-  // Verify that the extension was not installed.
-  EXPECT_FALSE(extension_service->GetExtensionById(kGoodExtensionID, true));
-
-  // Verify that the app was copied to the account's extension cache.
-  base::FilePath test_dir;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir));
-  EXPECT_TRUE(ContentsEqual(
-          GetCacheCRXFile(kAccountId1, kHostedAppID, kHostedAppVersion),
-          test_dir.Append(kHostedAppCRXPath)));
-
-  // Verify that the extension was not copied to the account's extension cache.
-  EXPECT_FALSE(PathExists(GetCacheCRXFile(
-      kAccountId1, kGoodExtensionID, kGoodExtensionVersion)));
-}
-
-IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExtensionsCached) {
-  ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
-
-  // Pre-populate the device local account's extension cache with a hosted app
-  // and an extension.
-  EXPECT_TRUE(file_util::CreateDirectory(
-      GetCacheDirectoryForAccountID(kAccountId1)));
-  base::FilePath test_dir;
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir));
-  const base::FilePath cached_hosted_app =
-      GetCacheCRXFile(kAccountId1, kHostedAppID, kHostedAppVersion);
-  EXPECT_TRUE(CopyFile(test_dir.Append(kHostedAppCRXPath),
-                       cached_hosted_app));
-  const base::FilePath cached_extension =
-      GetCacheCRXFile(kAccountId1, kGoodExtensionID, kGoodExtensionVersion);
-  EXPECT_TRUE(CopyFile(test_dir.Append(kGoodExtensionCRXPath),
-                       cached_extension));
-
-  // Specify policy to force-install the hosted app.
-  em::StringList* forcelist = device_local_account_policy_.payload()
-      .mutable_extensioninstallforcelist()->mutable_value();
-  forcelist->add_entries(base::StringPrintf(
-      "%s;%s",
-      kHostedAppID,
-      embedded_test_server()->GetURL(kRelativeUpdateURL).spec().c_str()));
-  forcelist->add_entries(base::StringPrintf(
-      "%s;%s",
-      kGoodExtensionID,
-      embedded_test_server()->GetURL(kRelativeUpdateURL).spec().c_str()));
-
-  UploadAndInstallDeviceLocalAccountPolicy();
-  AddPublicSessionToDevicePolicy(kAccountId1);
-
-  // This observes the display name becoming available as this indicates
-  // device-local account policy is fully loaded, which is a prerequisite for
-  // successful login.
-  content::WindowedNotificationObserver(
-      chrome::NOTIFICATION_USER_LIST_CHANGED,
-      base::Bind(&DisplayNameMatches, user_id_1_, kDisplayName)).Wait();
-
-  // Wait for the login UI to be ready.
-  chromeos::LoginDisplayHostImpl* host =
-      reinterpret_cast<chromeos::LoginDisplayHostImpl*>(
-          chromeos::LoginDisplayHostImpl::default_host());
-  ASSERT_TRUE(host);
-  chromeos::OobeUI* oobe_ui = host->GetOobeUI();
-  ASSERT_TRUE(oobe_ui);
-  base::RunLoop run_loop;
-  const bool oobe_ui_ready = oobe_ui->IsJSReady(run_loop.QuitClosure());
-  if (!oobe_ui_ready)
-    run_loop.Run();
-
-  // Ensure that the browser stays alive, even though no windows are opened
-  // during session start.
-  chrome::StartKeepAlive();
-
-  // Start listening for app/extension installation results.
-  content::WindowedNotificationObserver hosted_app_observer(
-      chrome::NOTIFICATION_EXTENSION_INSTALLED,
-      base::Bind(DoesInstallSuccessReferToId, kHostedAppID));
-  content::WindowedNotificationObserver extension_observer(
-      chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
-      base::Bind(DoesInstallFailureReferToId, kGoodExtensionID));
-
-  // Start login into the device-local account.
-  host->StartSignInScreen();
-  chromeos::ExistingUserController* controller =
-      chromeos::ExistingUserController::current_controller();
-  ASSERT_TRUE(controller);
-  controller->LoginAsPublicAccount(user_id_1_);
-
-  // Wait for the hosted app installation to succeed and the extension
   // installation to fail.
   hosted_app_observer.Wait();
   extension_observer.Wait();
 
   // Verify that the hosted app was installed.
   Profile* profile = ProfileManager::GetDefaultProfile();
   ASSERT_TRUE(profile);
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   EXPECT_TRUE(extension_service->GetExtensionById(kHostedAppID, true));
 
   // Verify that the extension was not installed.
   EXPECT_FALSE(extension_service->GetExtensionById(kGoodExtensionID, true));
-
-  // Verify that the app is still in the account's extension cache.
-  EXPECT_TRUE(PathExists(cached_hosted_app));
-
-  // Verify that the extension was removed from the account's extension cache.
-  EXPECT_FALSE(PathExists(cached_extension));
 }
 
 class TermsOfServiceTest : public DeviceLocalAccountTest,
                            public testing::WithParamInterface<bool> {
 };
 
 IN_PROC_BROWSER_TEST_P(TermsOfServiceTest, TermsOfServiceScreen) {
   // Specify Terms of Service URL.
   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
   device_local_account_policy_.payload().mutable_termsofserviceurl()->set_value(
@@ skipping 143 matching lines @@
   if (!IsSessionStarted()) {
     content::WindowedNotificationObserver(chrome::NOTIFICATION_SESSION_STARTED,
                                           base::Bind(IsSessionStarted)).Wait();
   }
 }
 
 INSTANTIATE_TEST_CASE_P(TermsOfServiceTestInstance,
                         TermsOfServiceTest, testing::Bool());
 
 }  // namespace policy