[Sync] Move some extension-sync-related logic to ExtensionService

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2011 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/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 10 matching lines @@
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_creator.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
+#include "chrome/browser/extensions/extension_sync_data.h"
+#include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/external_extension_provider_impl.h"
 #include "chrome/browser/extensions/external_extension_provider_interface.h"
 #include "chrome/browser/extensions/external_pref_extension_loader.h"
 #include "chrome/browser/extensions/pack_extension_job.cc"
+#include "chrome/browser/extensions/pending_extension_info.h"
+#include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "chrome/common/json_value_serializer.h"
@@ skipping 343 matching lines @@
 ExtensionServiceTestBase::~ExtensionServiceTestBase() {
   // Drop our reference to ExtensionService and TestingProfile, so that they
   // can be destroyed while BrowserThreads and MessageLoop are still around
   // (they are used in the destruction process).
   service_ = NULL;
   profile_.reset(NULL);
   MessageLoop::current()->RunAllPending();
 }
 
 void ExtensionServiceTestBase::InitializeExtensionService(
-    const FilePath& pref_file, const FilePath& extensions_install_dir) {
+    const FilePath& pref_file, const FilePath& extensions_install_dir,
+    bool autoupdate_enabled) {
   ExtensionTestingProfile* profile = new ExtensionTestingProfile();
   // Create a PrefService that only contains user defined preference values.
   PrefService* prefs =
       PrefServiceMockBuilder().WithUserFilePrefs(pref_file).Create();
   Profile::RegisterUserPrefs(prefs);
   browser::RegisterUserPrefs(prefs);
   profile->SetPrefService(prefs);
 
   profile_.reset(profile);
 
   service_ = profile->CreateExtensionService(
       CommandLine::ForCurrentProcess(),
-      extensions_install_dir);
+      extensions_install_dir,
+      autoupdate_enabled);
   service_->set_extensions_enabled(true);
   service_->set_show_extensions_prompts(false);
   profile->set_extensions_service(service_.get());
 
   // When we start up, we want to make sure there is no external provider,
   // since the ExtensionService on Windows will use the Registry as a default
   // provider and if there is something already registered there then it will
   // interfere with the tests. Those tests that need an external provider
   // will register one specifically.
   service_->ClearProvidersForTesting();
 
   total_successes_ = 0;
 }
 
 void ExtensionServiceTestBase::InitializeInstalledExtensionService(
     const FilePath& prefs_file, const FilePath& source_install_dir) {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   FilePath path_ = temp_dir_.path();
   path_ = path_.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
   file_util::Delete(path_, true);
   file_util::CreateDirectory(path_);
   FilePath temp_prefs = path_.Append(FILE_PATH_LITERAL("Preferences"));
   file_util::CopyFile(prefs_file, temp_prefs);
 
   extensions_install_dir_ = path_.Append(FILE_PATH_LITERAL("Extensions"));
   file_util::Delete(extensions_install_dir_, true);
   file_util::CopyDirectory(source_install_dir, extensions_install_dir_, true);
 
-  InitializeExtensionService(temp_prefs, extensions_install_dir_);
+  InitializeExtensionService(temp_prefs, extensions_install_dir_, false);
 }
 
 void ExtensionServiceTestBase::InitializeEmptyExtensionService() {
+  InitializeExtensionServiceHelper(false);
+}
+
+void ExtensionServiceTestBase::InitializeExtensionServiceWithUpdater() {
+  InitializeExtensionServiceHelper(true);
+  service_->updater()->Start();
+}
+
+void ExtensionServiceTestBase::InitializeExtensionServiceHelper(
+    bool autoupdate_enabled) {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   FilePath path_ = temp_dir_.path();
   path_ = path_.Append(FILE_PATH_LITERAL("TestingExtensionsPath"));
   file_util::Delete(path_, true);
   file_util::CreateDirectory(path_);
   FilePath prefs_filename = path_
       .Append(FILE_PATH_LITERAL("TestPreferences"));
   extensions_install_dir_ = path_.Append(FILE_PATH_LITERAL("Extensions"));
   file_util::Delete(extensions_install_dir_, true);
   file_util::CreateDirectory(extensions_install_dir_);
 
-  InitializeExtensionService(prefs_filename, extensions_install_dir_);
+  InitializeExtensionService(prefs_filename, extensions_install_dir_,
+                             autoupdate_enabled);
 }
 
 // static
 void ExtensionServiceTestBase::SetUpTestCase() {
   ExtensionErrorReporter::Init(false);  // no noisy errors
 }
 
 void ExtensionServiceTestBase::SetUp() {
   ExtensionErrorReporter::GetInstance()->ClearErrors();
 }
@@ skipping 2786 matching lines @@
   BrowserThread ui_thread(BrowserThread::UI, &loop);
   BrowserThread file_thread(BrowserThread::FILE, &loop);
   scoped_ptr<CommandLine> command_line;
   scoped_refptr<ExtensionService> service;
   FilePath install_dir = profile->GetPath()
       .AppendASCII(ExtensionService::kInstallDirectoryName);
 
   // By default, we are enabled.
   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
   service = profile->CreateExtensionService(command_line.get(),
-                                            install_dir);
+                                            install_dir,
+                                            false);
   EXPECT_TRUE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   // If either the command line or pref is set, we are disabled.
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   command_line->AppendSwitch(switches::kDisableExtensions);
   service = profile->CreateExtensionService(command_line.get(),
-                                             install_dir);
+                                            install_dir,
+                                            false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
   service = profile->CreateExtensionService(command_line.get(),
-                                            install_dir);
+                                            install_dir,
+                                            false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   recorder.set_ready(false);
   profile.reset(new TestingProfile());
   profile->GetPrefs()->SetBoolean(prefs::kDisableExtensions, true);
   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
   service = profile->CreateExtensionService(command_line.get(),
-                                             install_dir);
+                                            install_dir,
+                                            false);
   EXPECT_FALSE(service->extensions_enabled());
   service->Init();
   loop.RunAllPending();
   EXPECT_TRUE(recorder.ready());
 
   // Explicitly delete all the resources used in this test.
   profile.reset();
   service = NULL;
 }
 
@@ skipping 91 matching lines @@
   ValidatePrefKeyCount(0);
 
   // Reload all extensions, and make sure it comes back.
   std::string extension_id = service_->extensions()->at(0)->id();
   loaded_.clear();
   service_->ReloadExtensions();
   ASSERT_EQ(1u, service_->extensions()->size());
   EXPECT_EQ(extension_id, service_->extensions()->at(0)->id());
 }
 
+TEST_F(ExtensionServiceTest, ProcessSyncDataUninstall) {
+  InitializeEmptyExtensionService();
+
+  ExtensionSyncData extension_sync_data;
+  extension_sync_data.id = good_crx;
+  extension_sync_data.uninstalled = true;
+
+  // Should do nothing.
+  service_->ProcessSyncData(extension_sync_data);
+
+  // Install the extension.
+  FilePath extension_path = data_dir_.AppendASCII("good.crx");
+  InstallCrx(extension_path, true);
+  EXPECT_TRUE(service_->GetExtensionById(good_crx, true));
+
+  // Should uninstall the extension.
+  service_->ProcessSyncData(extension_sync_data);
+  EXPECT_FALSE(service_->GetExtensionById(good_crx, true));
+
+  // Should again do nothing.
+  service_->ProcessSyncData(extension_sync_data);
+}
+
+
+TEST_F(ExtensionServiceTest, ProcessSyncDataSettings) {
+  InitializeEmptyExtensionService();
+
+  FilePath extension_path = data_dir_.AppendASCII("good.crx");
+  InstallCrx(extension_path, true);
+  EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
+  EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
+
+  ExtensionSyncData extension_sync_data;
+  extension_sync_data.id = good_crx;
+  extension_sync_data.version =
+      *(service_->GetExtensionById(good_crx, true)->version());
+
+  extension_sync_data.enabled = false;
+  service_->ProcessSyncData(extension_sync_data);
+  EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
+  EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
+
+  extension_sync_data.enabled = true;
+  extension_sync_data.incognito_enabled = true;
+  service_->ProcessSyncData(extension_sync_data);
+  EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
+  EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
+
+  extension_sync_data.enabled = false;
+  extension_sync_data.incognito_enabled = true;
+  service_->ProcessSyncData(extension_sync_data);
+  EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
+  EXPECT_TRUE(service_->IsIncognitoEnabled(good_crx));
+
+  EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
+}
+
+TEST_F(ExtensionServiceTest, ProcessSyncDataVersionCheck) {
+  InitializeExtensionServiceWithUpdater();
+
+  // Install the extension.
+  FilePath extension_path = data_dir_.AppendASCII("good.crx");
+  InstallCrx(extension_path, true);
+  EXPECT_TRUE(service_->IsExtensionEnabled(good_crx));
+  EXPECT_FALSE(service_->IsIncognitoEnabled(good_crx));
+
+  ExtensionSyncData extension_sync_data;
+  extension_sync_data.id = good_crx;
+  extension_sync_data.enabled = true;
+  extension_sync_data.version =
+      *(service_->GetExtensionById(good_crx, true)->version());
+
+  // Should do nothing if extension version == sync version.
+  service_->ProcessSyncData(extension_sync_data);
+  EXPECT_FALSE(service_->updater()->WillCheckSoon());
+
+  // Should do nothing if extension version > sync version (but see
+  // the TODO in ProcessSyncData).
+  {
+    scoped_ptr<Version> version(Version::GetVersionFromString("0.0.0.0"));
+    extension_sync_data.version = *version;
+    service_->ProcessSyncData(extension_sync_data);
+    EXPECT_FALSE(service_->updater()->WillCheckSoon());
+  }
+
+  // Should kick off an update if extension version < sync version.
+  {
+    scoped_ptr<Version> version(Version::GetVersionFromString("9.9.9.9"));
+    extension_sync_data.version = *version;
+    service_->ProcessSyncData(extension_sync_data);
+    EXPECT_TRUE(service_->updater()->WillCheckSoon());
+  }
+
+  EXPECT_FALSE(service_->pending_extension_manager()->IsIdPending(good_crx));
+}
+
+TEST_F(ExtensionServiceTest, ProcessSyncDataNotInstalled) {
+  InitializeExtensionServiceWithUpdater();
+
+  ExtensionSyncData extension_sync_data;
+  extension_sync_data.id = good_crx;
+  extension_sync_data.update_url = GURL("http://www.google.com");
+  extension_sync_data.enabled = true;
+  {
+    scoped_ptr<Version> version(Version::GetVersionFromString("1.2.3.4"));
+    extension_sync_data.version = *version;
+  }
+
+  service_->ProcessSyncData(extension_sync_data);
+  EXPECT_TRUE(service_->updater()->WillCheckSoon());
+
+  PendingExtensionInfo info;
+  EXPECT_TRUE(
+      service_->pending_extension_manager()->GetById(good_crx, &info));
+  EXPECT_EQ(extension_sync_data.update_url, info.update_url());
+  EXPECT_TRUE(info.is_from_sync());
+  EXPECT_TRUE(info.install_silently());
+  EXPECT_EQ(extension_sync_data.enabled, info.enable_on_install());
+  EXPECT_EQ(extension_sync_data.incognito_enabled,
+            info.enable_incognito_on_install());
+  EXPECT_EQ(Extension::INTERNAL, info.install_source());
+  // TODO(akalin): Figure out a way to test |info.ShouldAllowInstall()|.
+}
+
 // Test that when multiple sources try to install an extension,
 // we consistently choose the right one. To make tests easy to read,
 // methods that fake requests to install crx files in several ways
 // are provided.
 class ExtensionSourcePriorityTest : public ExtensionServiceTest {
  public:
   void SetUp() {
     // All tests use a single extension.  Put the id and path in member vars
     // that all methods can read.
     crx_id_ = kGoodId;
@@ skipping 157 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, true);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }