Add a test for KeywordExtensionsDelegateImpl::IsEnabledExtension().

chrome/browser/autocomplete/keyword_extensions_delegate_impl_unittest.cc

+// Copyright 2014 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/autocomplete/keyword_extensions_delegate_impl.h"
+
+#include "base/memory/ref_counted.h"
+#include "base/path_service.h"
+#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/extension_service_test_base.h"
+#include "chrome/browser/extensions/extension_util.h"
+#include "chrome/browser/extensions/test_extension_system.h"
+#include "chrome/browser/extensions/unpacked_installer.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_paths.h"
+#include "components/omnibox/keyword_provider.h"
+#include "components/search_engines/template_url_service.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_registry_observer.h"
+#include "extensions/common/extension.h"
+
+namespace extensions {
+
+namespace {
+
+class ExtensionLoadObserver : public ExtensionRegistryObserver {

[Yoyo Zhou, 2014/09/05 16:21:33]

Consider making this a ScopedExtensionLoadObserver.
In the constructor, AddObserver, and destructor, RemoveObserver.

[Lei Zhang, 2014/09/05 19:35:08]

Done.

+ public:
+  explicit ExtensionLoadObserver(const base::Closure& quit_closure);
+  virtual ~ExtensionLoadObserver() {}
+
+ private:
+  virtual void OnExtensionInstalled(content::BrowserContext* browser_context,
+                                    const Extension* extension,
+                                    bool is_update) OVERRIDE;
+
+  base::Closure quit_closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtensionLoadObserver);
+};
+
+ExtensionLoadObserver::ExtensionLoadObserver(const base::Closure& quit_closure)
+    : quit_closure_(quit_closure) {
+}
+
+void ExtensionLoadObserver::OnExtensionInstalled(
+    content::BrowserContext* browser_context,
+    const Extension* extension,
+    bool is_update) {
+  quit_closure_.Run();
+}
+
+class KeywordExtensionsDelegateImplTest : public ExtensionServiceTestBase {
+ public:
+  KeywordExtensionsDelegateImplTest() {}
+  virtual ~KeywordExtensionsDelegateImplTest() {}
+
+ protected:
+  virtual void SetUp() OVERRIDE;
+  virtual void TearDown() OVERRIDE;
+
+  void RunTest(bool incognito);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(KeywordExtensionsDelegateImplTest);
+};
+
+void KeywordExtensionsDelegateImplTest::SetUp() {
+  ExtensionServiceTestBase::SetUp();
+  InitializeExtensionService(CreateDefaultInitParams());
+
+  TestExtensionSystem* extension_system =
+      static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile()));
+  extension_system->CreateProcessManager();

[Yoyo Zhou, 2014/09/05 16:21:33]

This is all just InitializeProcessManager()

[Lei Zhang, 2014/09/05 19:35:08]

Done.

+
+  TestExtensionSystem* incognito_extension_system =
+      static_cast<TestExtensionSystem*>(
+          ExtensionSystem::Get(profile()->GetOffTheRecordProfile()));
+  incognito_extension_system->SetExtensionService(
+      service(), false /* does not take ownership */);
+}
+
+void KeywordExtensionsDelegateImplTest::TearDown() {
+  TestExtensionSystem* incognito_extension_system =
+      static_cast<TestExtensionSystem*>(
+          ExtensionSystem::Get(profile()->GetOffTheRecordProfile()));
+  incognito_extension_system->SetExtensionService(
+      NULL, false /* does not take ownership */);
+}
+
+void KeywordExtensionsDelegateImplTest::RunTest(bool incognito) {
+  TemplateURLService empty_model(NULL, 0);
+  scoped_refptr<KeywordProvider> keyword_provider =
+      new KeywordProvider(NULL, &empty_model);
+
+  // Load an extension.
+  {
+    base::FilePath path;
+    ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &path));
+    path = path.AppendASCII("extensions").AppendASCII("good_unpacked");
+
+    base::RunLoop run_loop;
+    ExtensionLoadObserver load_observer(run_loop.QuitClosure());
+    registry()->AddObserver(&load_observer);
+
+    scoped_refptr<UnpackedInstaller> installer(
+        UnpackedInstaller::Create(service()));
+    installer->Load(path);
+
+    run_loop.Run();
+    registry()->RemoveObserver(&load_observer);
+  }
+
+  ASSERT_EQ(1U, registry()->enabled_extensions().size());
+  scoped_refptr<const Extension> extension =
+      *(registry()->enabled_extensions().begin());
+  ASSERT_FALSE(util::IsIncognitoEnabled(extension->id(), profile()));
+
+  Profile* profile_to_use = incognito ?
+      profile()->GetOffTheRecordProfile() : profile();
+  KeywordExtensionsDelegateImpl delegate_impl(profile_to_use,

[Yoyo Zhou, 2014/09/05 16:21:33]

Here's a suggestion. We could use dependency injection for
KeywordExtensionDelegateImpl so that its constructor takes (Profile*,
ExtensionService*, KeywordProvider*) and just pass in service() here. This would
allow us to skip the association with the incognito profile here (and the
changes to TestExtensionSystem). This does make the implementation a little bit
more constrained, but it is a test for an Impl class anyways.

[Lei Zhang, 2014/09/05 19:35:08]

Better yet, I'm just going to take this portion of my other cleanup CL and use
it in this CL instead. THen we don't have to inject an ExtensionService*.

https://codereview.chromium.org/543693003/diff/40001/chrome/browser/autocompl...

+                                              keyword_provider.get());
+  KeywordExtensionsDelegate* delegate = &delegate_impl;
+  EXPECT_NE(incognito, delegate->IsEnabledExtension(extension->id()));
+
+  // Enable the extension in incognito mode, which requires a reload.
+  {
+    base::RunLoop run_loop;
+    ExtensionLoadObserver load_observer(run_loop.QuitClosure());
+    registry()->AddObserver(&load_observer);
+
+    util::SetIsIncognitoEnabled(extension->id(), profile(), true);
+
+    run_loop.Run();
+    registry()->RemoveObserver(&load_observer);
+  }
+
+  ASSERT_EQ(1U, registry()->enabled_extensions().size());
+  extension = *(registry()->enabled_extensions().begin());
+  ASSERT_TRUE(util::IsIncognitoEnabled(extension->id(), profile()));
+  EXPECT_TRUE(delegate->IsEnabledExtension(extension->id()));
+}
+
+TEST_F(KeywordExtensionsDelegateImplTest, IsEnabledExtension) {
+  RunTest(false);
+}
+
+TEST_F(KeywordExtensionsDelegateImplTest, IsEnabledExtensionIncognito) {
+  RunTest(true);
+}
+
+}  // namespace
+
+}  // namespace extensions