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

chrome/browser/extensions/extension_service_unittest.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 <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
@@ skipping 3566 matching lines @@
   service()->ReloadExtension(good2);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(StringSet(good0), registry()->enabled_extensions().GetIDs());
   EXPECT_EQ(StringSet(good1, good2),
             registry()->blacklisted_extensions().GetIDs());
 }
 
 #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();
 
   // Blacklist everything.
   {
     ManagementPrefUpdater pref(profile_->GetTestingPrefService());
     pref.SetBlacklistedByDefault(true);
   }
 
@@ skipping 3758 matching lines @@
 
   service()->Observe(chrome::NOTIFICATION_PROFILE_DESTRUCTION_STARTED,
                      content::Source<Profile>(profile()),
                      content::NotificationService::NoDetails());
   EXPECT_EQ(UnloadedExtensionInfo::REASON_PROFILE_SHUTDOWN, unloaded_reason_);
   EXPECT_EQ(0u, registry()->enabled_extensions().size());
   EXPECT_EQ(0u, registry()->disabled_extensions().size());
   EXPECT_EQ(0u, registry()->terminated_extensions().size());
   EXPECT_EQ(0u, registry()->blacklisted_extensions().size());
 }