Add minimum version to extension management

chrome/browser/policy/policy_browsertest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_file_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/autocomplete/autocomplete_controller.h"
 #include "chrome/browser/background/background_contents_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/devtools/devtools_window_testing.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/extensions/api/messaging/message_service.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_management_constants.h"
+#include "chrome/browser/extensions/extension_management_test_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/shared_module_service.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_cache_fake.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/media_stream_devices_controller.h"
 #include "chrome/browser/metrics/variations/variations_service.h"
 #include "chrome/browser/net/prediction_options.h"
@@ skipping 72 matching lines @@
 #include "content/public/common/process_type.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/download_test_observer.h"
 #include "content/public/test/mock_notification_observer.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_host.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/test_extension_registry_observer.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest_handlers/shared_module_info.h"
 #include "net/base/net_errors.h"
@@ skipping 67 matching lines @@
     FILE_PATH_LITERAL("hosted_app.crx");
 
 const char kGoodCrxId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char kAdBlockCrxId[] = "dojnnbeimaimaojcialkkgajdnefpgcn";
 const char kHostedAppCrxId[] = "kbmnembihfiondgfjekmnmcbddelicoi";
 
 const base::FilePath::CharType kGood2CrxManifestName[] =
     FILE_PATH_LITERAL("good2_update_manifest.xml");
 const base::FilePath::CharType kGoodV1CrxManifestName[] =
     FILE_PATH_LITERAL("good_v1_update_manifest.xml");
+const base::FilePath::CharType kGoodV1CrxName[] =
+    FILE_PATH_LITERAL("good_v1.crx");
 const base::FilePath::CharType kGoodUnpackedExt[] =
     FILE_PATH_LITERAL("good_unpacked");
 const base::FilePath::CharType kAppUnpackedExt[] =
     FILE_PATH_LITERAL("app");
 
 #if !defined(OS_MACOSX)
 const base::FilePath::CharType kUnpackedFullscreenAppName[] =
     FILE_PATH_LITERAL("fullscreen_app");
 #endif  // !defined(OS_MACOSX)
 
@@ skipping 1721 matching lines @@
   observer.Wait();
   // Note: Cannot check that the notification details match the expected
   // exception, since the details object has already been freed prior to
   // the completion of observer.Wait().
 
   // The first extension shouldn't be present, the second should be there.
   EXPECT_FALSE(extension_service()->GetExtensionById(kGoodCrxId, true));
   EXPECT_TRUE(extension_service()->GetExtensionById(kAdBlockCrxId, false));
 }
 
+// Verifies that extensions with version older than minimum version required by
+// policy will get disabled, and will be auto-updated and/or re-enabled upon
+// policy changes as well as regular auto-updater scheduled updates.
+IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionMinimumVersionRequired) {
+  ExtensionService* service = extension_service();
+  extensions::ExtensionRegistry* registry =
+      extensions::ExtensionRegistry::Get(browser()->profile());
+  extensions::ExtensionPrefs* extension_prefs =
+      extensions::ExtensionPrefs::Get(browser()->profile());
+
+  // Explicitly stop the timer to avoid all scheduled extension auto-updates.
+  service->updater()->StopTimerForTesting();
+
+  // Setup interceptor for extension updates.
+  base::FilePath test_path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_path));
+  TestRequestInterceptor interceptor(
+      "update.extension",
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
+  interceptor.PushJobCallback(TestRequestInterceptor::BadRequestJob());
+  interceptor.PushJobCallback(TestRequestInterceptor::FileJob(
+      test_path.Append(kTestExtensionsDir).Append(kGood2CrxManifestName)));
+
+  // Install the extension.
+  ASSERT_TRUE(InstallExtension(kGoodV1CrxName));
+  ASSERT_TRUE(registry->enabled_extensions().Contains(kGoodCrxId));
+
+  // Update policy to set a minimum version of 1.0.0.0, the extension (with
+  // version 1.0.0.0) should still be enabled.
+  {
+    extensions::ExtensionManagementPolicyUpdater management_policy(&provider_);
+    management_policy.SetMinimumVersionRequired(kGoodCrxId, "1.0.0.0");
+  }
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_TRUE(registry->enabled_extensions().Contains(kGoodCrxId));
+
+  // Update policy to set a minimum version of 1.0.0.1, the extension (with
+  // version 1.0.0.0) should now be disabled.
+  ASSERT_EQ(2u, interceptor.GetPendingSize());
+  {
+    extensions::ExtensionManagementPolicyUpdater management_policy(&provider_);
+    management_policy.SetMinimumVersionRequired(kGoodCrxId, "1.0.0.1");
+  }
+  {
+    // Wait until the first bad request is consumed.
+    base::RunLoop run_loop;
+    interceptor.AddRequestServicedCallback(base::Bind(

[Joao da Silva, 2014/12/03 12:25:45]

This must be prepared before the policy is modified, otherwise it's going to be
racy.

Try this instead:

ASSERT_EQ(2u, interceptor.GetPendingSize());
base::RunLoop service_request_run_loop;
interceptor.AddRequestServicedCallback(service_request_run_loop.QuitClosure());
{
  // change the policy
}
service_request_run_loop.Run();

Note also that you can pass the QuitClosure directly as the callback, no need to
bind another PostTask.

[binjin, 2014/12/03 12:40:00]

Done.

+        base::IgnoreResult(&base::MessageLoopProxy::PostTask),
+        base::MessageLoopProxy::current(), FROM_HERE, run_loop.QuitClosure()));
+    run_loop.Run();
+  }
+  ASSERT_EQ(1u, interceptor.GetPendingSize());
+
+  ASSERT_TRUE(registry->disabled_extensions().Contains(kGoodCrxId));
+  EXPECT_EQ(extensions::Extension::DISABLE_UPDATE_REQUIRED_BY_POLICY,
+            extension_prefs->GetDisableReasons(kGoodCrxId));
+
+  // Provide a new version (1.0.0.1) which is expected to be auto updated to
+  // via update URL in the manifest of the older version.
+  ASSERT_EQ(1u, interceptor.GetPendingSize());
+  {
+    content::WindowedNotificationObserver update_observer(
+        extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
+        content::NotificationService::AllSources());
+    service->updater()->CheckSoon();
+    update_observer.Wait();
+  }
+  ASSERT_EQ(0u, interceptor.GetPendingSize());
+
+  // The extension should be auto-updated to newer version and re-enabled.
+  EXPECT_EQ("1.0.0.1",
+            service->GetInstalledExtension(kGoodCrxId)->version()->GetString());
+  EXPECT_TRUE(registry->enabled_extensions().Contains(kGoodCrxId));
+}
+
+// Similar to ExtensionMinimumVersionRequired test, but with different settings
+// and orders.
+IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionMinimumVersionRequiredAlt) {
+  ExtensionService* service = extension_service();
+  extensions::ExtensionRegistry* registry =
+      extensions::ExtensionRegistry::Get(browser()->profile());
+  extensions::ExtensionPrefs* extension_prefs =
+      extensions::ExtensionPrefs::Get(browser()->profile());
+
+  // Explicitly stop the timer to avoid all scheduled extension auto-updates.
+  service->updater()->StopTimerForTesting();
+
+  // Setup interceptor for extension updates.
+  base::FilePath test_path;
+  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_path));
+  TestRequestInterceptor interceptor(
+      "update.extension",
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO));
+  interceptor.PushJobCallback(TestRequestInterceptor::FileJob(
+      test_path.Append(kTestExtensionsDir).Append(kGood2CrxManifestName)));
+
+  // Set the policy to require an even higher minimum version this time.
+  {
+    extensions::ExtensionManagementPolicyUpdater management_policy(&provider_);
+    management_policy.SetMinimumVersionRequired(kGoodCrxId, "1.0.0.2");
+  }
+  base::RunLoop().RunUntilIdle();
+
+  // Install the 1.0.0.0 version, it should be installed but disabled.
+  ASSERT_TRUE(InstallExtension(kGoodV1CrxName));
+  ASSERT_TRUE(registry->disabled_extensions().Contains(kGoodCrxId));
+  EXPECT_EQ(extensions::Extension::DISABLE_UPDATE_REQUIRED_BY_POLICY,
+            extension_prefs->GetDisableReasons(kGoodCrxId));
+  EXPECT_EQ("1.0.0.0",
+            service->GetInstalledExtension(kGoodCrxId)->version()->GetString());
+
+  // An extension management policy update should trigger an update as well.
+  ASSERT_EQ(1u, interceptor.GetPendingSize());
+  {
+    content::WindowedNotificationObserver update_observer(
+        extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
+        content::NotificationService::AllSources());
+    {
+      // Set a higher minimum version, just intend to trigger an policy update.
+      extensions::ExtensionManagementPolicyUpdater management_policy(
+          &provider_);
+      management_policy.SetMinimumVersionRequired(kGoodCrxId, "1.0.0.3");
+    }
+    base::RunLoop().RunUntilIdle();
+    update_observer.Wait();
+  }
+  ASSERT_EQ(0u, interceptor.GetPendingSize());
+
+  // It should be updated to 1.0.0.1 but remain disabled.
+  EXPECT_EQ("1.0.0.1",
+            service->GetInstalledExtension(kGoodCrxId)->version()->GetString());
+  EXPECT_TRUE(registry->disabled_extensions().Contains(kGoodCrxId));
+  EXPECT_EQ(extensions::Extension::DISABLE_UPDATE_REQUIRED_BY_POLICY,
+            extension_prefs->GetDisableReasons(kGoodCrxId));
+
+  // Remove the minimum version requirement, it should be re-enabled.
+  {
+    extensions::ExtensionManagementPolicyUpdater management_policy(&provider_);
+    management_policy.UnsetMinimumVersionRequired(kGoodCrxId);
+  }
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(registry->enabled_extensions().Contains(kGoodCrxId));
+  EXPECT_FALSE(extension_prefs->HasDisableReason(
+      kGoodCrxId, extensions::Extension::DISABLE_UPDATE_REQUIRED_BY_POLICY));
+}
+
+// Verifies that force installed missing the minimum version requirement is
+// handled well.
+IN_PROC_BROWSER_TEST_F(PolicyTest, ExtensionMinimumVersionForceInstalled) {
+  extensions::ExtensionRegistry* registry =
+      extensions::ExtensionRegistry::Get(browser()->profile());
+  extensions::ExtensionPrefs* extension_prefs =
+      extensions::ExtensionPrefs::Get(browser()->profile());
+
+  // Prepare the update URL for force installing.
+  base::FilePath path =
+      base::FilePath(kTestExtensionsDir).Append(kGoodV1CrxManifestName);
+  GURL url(URLRequestMockHTTPJob::GetMockUrl(path));
+
+  // Set policy to force install the extension, it should be installed and
+  // enabled.
+  content::WindowedNotificationObserver install_observer(
+      extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
+      content::NotificationService::AllSources());
+  ASSERT_FALSE(registry->enabled_extensions().Contains(kGoodCrxId));
+  {
+    extensions::ExtensionManagementPolicyUpdater management_policy(&provider_);
+    management_policy.SetIndividualExtensionAutoInstalled(kGoodCrxId,
+                                                          url.spec(), true);
+  }
+  base::RunLoop().RunUntilIdle();
+  install_observer.Wait();
+
+  ASSERT_TRUE(registry->enabled_extensions().Contains(kGoodCrxId));
+
+  // Set policy a minimum version of "1.0.0.1", the extension now should be
+  // disabled.
+  {
+    extensions::ExtensionManagementPolicyUpdater management_policy(&provider_);
+    management_policy.SetMinimumVersionRequired(kGoodCrxId, "1.0.0.1");
+  }
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(registry->enabled_extensions().Contains(kGoodCrxId));
+  EXPECT_TRUE(registry->disabled_extensions().Contains(kGoodCrxId));
+  EXPECT_EQ(extensions::Extension::DISABLE_UPDATE_REQUIRED_BY_POLICY,
+            extension_prefs->GetDisableReasons(kGoodCrxId));
+}
+
 IN_PROC_BROWSER_TEST_F(PolicyTest, HomepageLocation) {
 #if defined(OS_WIN) && defined(USE_ASH)
   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
     return;
 #endif
 
   // Verifies that the homepage can be configured with policies.
   // Set a default, and check that the home button navigates there.
   browser()->profile()->GetPrefs()->SetString(
@@ skipping 1458 matching lines @@
   EXPECT_TRUE(content::ExecuteScriptAndExtractBool(
       browser2->tab_strip_model()->GetActiveWebContents(),
       "domAutomationController.send(window.showModalDialog !== undefined);",
       &result));
   EXPECT_TRUE(result);
 }
 
 #endif  // !defined(CHROME_OS)
 
 }  // namespace policy