Temporarily disable extensions and sync while a profile is locked - Profiles Approach

chrome/browser/extensions/extension_service_unittest.cc

Index: chrome/browser/extensions/extension_service_unittest.cc
diff --git a/chrome/browser/extensions/extension_service_unittest.cc b/chrome/browser/extensions/extension_service_unittest.cc
index 0d7905fbd84226cb78a70a4f73b57e6ce1942bde..8dbaa632688bfb805441f30d5559b88a28ff7388 100644
--- a/chrome/browser/extensions/extension_service_unittest.cc
+++ b/chrome/browser/extensions/extension_service_unittest.cc
@@ -3584,6 +3584,105 @@ TEST_F(ExtensionServiceTest, ReloadBlacklistedExtension) {
 
 #endif  // defined(ENABLE_BLACKLIST_TESTS)
 
+// Tests blocking then unblocking extensions after the service has been
+// initialized.
+TEST_F(ExtensionServiceTest, SetUnsetBlockingState) {
+  // A profile with 3 extensions installed: good0, good1, and good2.
+  InitializeGoodInstalledExtensionService();
+  service()->Init();
+
+  const extensions::ExtensionSet& enabled_extensions =
+      registry()->enabled_extensions();
+  const extensions::ExtensionSet& blocked_extensions =
+      registry()->blocked_extensions();
+
+  EXPECT_TRUE(enabled_extensions.Contains(good0) &&
+              !blocked_extensions.Contains(good0));
+  EXPECT_TRUE(enabled_extensions.Contains(good1) &&
+              !blocked_extensions.Contains(good1));
+  EXPECT_TRUE(enabled_extensions.Contains(good2) &&
+              !blocked_extensions.Contains(good2));

[not at google - send to devlin, 2014/11/20 18:27:20]

It's better to separate the assertions rather than using &&, that way the
failure message is more meaningful. You know exactly what condition failed,
rather than it being one of two possible conditions.

You could do this neatly with a helper function (i.e. protected function on
ExtensionServiceTest) like this:

testing::AssertionResult IsBlocked(const std::string& id) {
  if (registry()->enabled_extensions().Contains(id))
    return testing:AssertionFailure() << id << " is still enabled";
  if (!registry()->blocked_extensions().Contains(id))
    return testing::AssertionFailure() << id << " is not blocked";
  return testing::AssertionSuccess();
}

...

EXPECT_TRUE(IsBlocked(good0));
EXPECT_TRUE(IsBlocked(good1));
...

You could even put some more/stronger assertions in that IsBlocked method. For
example, rather than enabled_extensions() use
GenerateInstallExtensionSet(EVERYTHING & ~BLOCKED) so that you get ever set
other than blocked.

[Mike Lerman, 2014/11/21 17:00:13]

Done.

+
+  // Block the extensions.
+  service()->BlockAllExtensions();
+  base::RunLoop().RunUntilIdle();
+
+  // All extensions should be blocked.
+  EXPECT_TRUE(!enabled_extensions.Contains(good0) &&
+              blocked_extensions.Contains(good0));
+  EXPECT_TRUE(!enabled_extensions.Contains(good1) &&
+              blocked_extensions.Contains(good1));
+  EXPECT_TRUE(!enabled_extensions.Contains(good2) &&
+              blocked_extensions.Contains(good2));
+
+  service()->UnblockAllExtensions();
+  base::RunLoop().RunUntilIdle();
+

[not at google - send to devlin, 2014/11/20 18:27:20]

I think it's also important to test some more cases here:

- a blacklisted extension, both one that is blacklisted before initialising
(make sure it's never blocked nor unblocked) and one that is blacklisted before
unblocking (likewise).

- a disable extension, similar situation.

- a terminated extension, similar situation.

[Mike Lerman, 2014/11/21 17:00:13]

Wrote a helper method to refactor the boiler plate involved here. Trying to help
prevent this file from hitting the 8000 line mark ;)

+  EXPECT_TRUE(enabled_extensions.Contains(good0) &&
+              !blocked_extensions.Contains(good0));
+  EXPECT_TRUE(enabled_extensions.Contains(good1) &&
+              !blocked_extensions.Contains(good1));
+  EXPECT_TRUE(enabled_extensions.Contains(good2) &&
+              !blocked_extensions.Contains(good2));
+}
+
+// Tests that blocking then unblocking the service doesn't affect component
+// extensions.

[not at google - send to devlin, 2014/11/20 18:27:20]

If possible could you also put policy extensions in here (if it's too hard then
don't worry about it, the code is fairly straightforward to see that you *do*
block it, but test coverage is nice)

[Mike Lerman, 2014/11/21 17:00:13]

I presume by "policy extension" you mean an extension that was force-installed
by policy, and that should be prohibited from blocking?

If so - Done.

+TEST_F(ExtensionServiceTest, SetUnsetBlockingStateComponent) {
+  InitializeEmptyExtensionServiceWithTestingPrefs();
+
+  service()->BlockAllExtensions();
+
+  // Install a component extension.
+  base::FilePath path = data_dir()
+                            .AppendASCII("good")
+                            .AppendASCII("Extensions")
+                            .AppendASCII(good0)
+                            .AppendASCII("1.0.0.0");
+  std::string manifest;
+  ASSERT_TRUE(base::ReadFileToString(
+      path.Append(extensions::kManifestFilename), &manifest));
+  service()->component_loader()->Add(manifest, path);
+  service()->Init();
+
+  // Should be enabled.
+  const extensions::ExtensionSet& enabled_extensions =
+      registry()->enabled_extensions();
+  const extensions::ExtensionSet& blocked_extensions =
+      registry()->blocked_extensions();
+
+  EXPECT_TRUE(enabled_extensions.Contains(good0) &&
+              !blocked_extensions.Contains(good0));
+
+  service()->UnblockAllExtensions();
+  base::RunLoop().RunUntilIdle();
+
+  // Still enabled.
+  EXPECT_TRUE(enabled_extensions.Contains(good0) &&
+              !blocked_extensions.Contains(good0));
+}
+
+// Tests that a blocked extension service won't load extensions.
+TEST_F(ExtensionServiceTest, WillNotLoadExtensionsWhenBlocked) {
+  InitializeGoodInstalledExtensionService();
+
+  service()->BlockAllExtensions();
+
+  service()->Init();
+
+  const extensions::ExtensionSet& enabled_extensions =
+      registry()->enabled_extensions();
+  const extensions::ExtensionSet& blocked_extensions =
+      registry()->blocked_extensions();
+
+  EXPECT_TRUE(!enabled_extensions.Contains(good0) &&
+              blocked_extensions.Contains(good0));
+  EXPECT_TRUE(!enabled_extensions.Contains(good1) &&
+              blocked_extensions.Contains(good1));
+  EXPECT_TRUE(!enabled_extensions.Contains(good2) &&
+              blocked_extensions.Contains(good2));
+}
+
 // Will not install extension blacklisted by policy.
 TEST_F(ExtensionServiceTest, BlacklistedByPolicyWillNotInstall) {
   InitializeEmptyExtensionServiceWithTestingPrefs();