Exclude PluginService for builds with enable_plugins==0

chrome/browser/extensions/extension_service_unittest.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 "chrome/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 998 matching lines @@
     msg += extension_id + " " + pref_path;
 
     ListValue* list_value = new ListValue();
     for (std::set<std::string>::const_iterator iter = value.begin();
          iter != value.end(); ++iter)
       list_value->Append(Value::CreateStringValue(*iter));
 
     SetPref(extension_id, pref_path, list_value, msg);
   }
 
+  void InitPluginService() {
+#if defined(ENABLE_PLUGINS)
+    PluginService::GetInstance()->Init();
+#endif
+  }
+
  protected:
   extensions::ExtensionList loaded_;
   std::string unloaded_id_;
   const Extension* installed_;
   FeatureSwitch::ScopedOverride override_external_install_prompt_;
 
  private:
   content::NotificationRegistrar registrar_;
 };
 
@@ skipping 39 matching lines @@
 void PackExtensionTestClient::OnPackFailure(const std::string& error_message,
                                             ExtensionCreator::ErrorType type) {
   if (type == ExtensionCreator::kCRXExists)
      FAIL() << "Packing should not fail.";
   else
      FAIL() << "Existing CRX should have been overwritten.";
 }
 
 // Test loading good extensions from the profile directory.
 TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectorySuccess) {
-  PluginService::GetInstance()->Init();
+  InitPluginService();
 
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 
@@ skipping 121 matching lines @@
 
   EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[3]),
       std::string("Could not load extension from '*'. ") +
       extension_manifest_errors::kManifestUnreadable)) <<
       UTF16ToUTF8(GetErrors()[3]);
 };
 
 // Test that partially deleted extensions are cleaned up during startup
 // Test loading bad extensions from the profile directory.
 TEST_F(ExtensionServiceTest, CleanupOnStartup) {
-  PluginService::GetInstance()->Init();
+  InitPluginService();
 
   FilePath source_install_dir = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
 
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 
@@ skipping 20 matching lines @@
 
   // And extension1 dir should now be toast.
   FilePath extension_dir = extensions_install_dir_
       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj");
   ASSERT_FALSE(file_util::PathExists(extension_dir));
 }
 
 // Test that GarbageCollectExtensions deletes the right versions of an
 // extension.
 TEST_F(ExtensionServiceTest, GarbageCollectWithPendingUpdates) {
-  PluginService::GetInstance()->Init();
+  InitPluginService();
 
   FilePath source_install_dir = data_dir_
       .AppendASCII("pending_updates")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
 
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 
@@ skipping 13 matching lines @@
   EXPECT_TRUE(file_util::PathExists(extensions_install_dir_.AppendASCII(
       "bjafgdebaacbbbecmhlhpofkepfkgcpa/2.0")));
   EXPECT_TRUE(file_util::PathExists(extensions_install_dir_.AppendASCII(
       "hpiknbiabeeppbpihjehijgoemciehgk/2")));
   EXPECT_FALSE(file_util::PathExists(extensions_install_dir_.AppendASCII(
       "hpiknbiabeeppbpihjehijgoemciehgk/3")));
 }
 
 // Test that pending updates are properly handled on startup.
 TEST_F(ExtensionServiceTest, UpdateOnStartup) {
-  PluginService::GetInstance()->Init();
+  InitPluginService();
 
   FilePath source_install_dir = data_dir_
       .AppendASCII("pending_updates")
       .AppendASCII("Extensions");
   FilePath pref_path = source_install_dir
       .DirName()
       .AppendASCII("Preferences");
 
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 
@@ skipping 383 matching lines @@
   EXPECT_EQ(expected_api_perms, known_perms->apis());
   EXPECT_FALSE(known_perms->HasEffectiveFullAccess());
 }
 #endif
 
 #if !defined(OS_CHROMEOS)
 // Tests that the granted permissions full_access bit gets set correctly when
 // an extension contains an NPAPI plugin. Don't run this test on Chrome OS
 // since they don't support plugins.
 TEST_F(ExtensionServiceTest, GrantedFullAccessPermissions) {
-  PluginService::GetInstance()->Init();
+  InitPluginService();
 
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII(good1)
       .AppendASCII("2");
 
   ASSERT_TRUE(file_util::PathExists(path));
@@ skipping 918 matching lines @@
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII(good1)
       .AppendASCII("2");
   FilePath extension_no_plugin_path = data_dir_
       .AppendASCII("good")
       .AppendASCII("Extensions")
       .AppendASCII(good2)
       .AppendASCII("1.0");
 
-  PluginService::GetInstance()->Init();
+  InitPluginService();
   InitializeEmptyExtensionService();
   InitializeExtensionProcessManager();
   service_->set_show_extensions_prompts(true);
 
   // Start by canceling any install prompts.
   CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kAppsGalleryInstallAutoConfirmForTests,
       "cancel");
 
   // The extension that has a plugin should not install.
@@ skipping 1855 matching lines @@
   ExtensionErrorReporter::Init(false);  // no noisy errors
   ExtensionsReadyRecorder recorder;
   scoped_ptr<TestingProfile> profile(new TestingProfile());
   MessageLoop loop;
   content::TestBrowserThread ui_thread(BrowserThread::UI, &loop);
   content::TestBrowserThread file_thread(BrowserThread::FILE, &loop);
   scoped_ptr<CommandLine> command_line;
   FilePath install_dir = profile->GetPath()
       .AppendASCII(ExtensionService::kInstallDirectoryName);
 
+#if defined(ENABLE_PLUGINS)
   webkit::npapi::MockPluginList plugin_list;
   PluginService::GetInstance()->SetPluginListForTesting(&plugin_list);
+#endif
 
   // By default, we are enabled.
   command_line.reset(new CommandLine(CommandLine::NO_PROGRAM));
   ExtensionService* service = static_cast<extensions::TestExtensionSystem*>(
       ExtensionSystem::Get(profile.get()))->
       CreateExtensionService(
           command_line.get(),
           install_dir,
           false);
   EXPECT_TRUE(service->extensions_enabled());
@@ skipping 44 matching lines @@
   service->Init();
   loop.RunUntilIdle();
   EXPECT_TRUE(recorder.ready());
 
   // Explicitly delete all the resources used in this test.
   profile.reset();
   service = NULL;
   // Execute any pending deletion tasks.
   loop.RunUntilIdle();
 
+#if defined(ENABLE_PLUGINS)
   // Ensure that even if the PluginService is re-used for a later test, it
   // won't still hold a reference to the stack position of our MockPluginList.
   // See crbug.com/159754.
   PluginService::GetInstance()->SetPluginListForTesting(NULL);
+#endif
 }
 
 // Test loading extensions that require limited and unlimited storage quotas.
 TEST_F(ExtensionServiceTest, StorageQuota) {
   InitializeEmptyExtensionService();
 
   FilePath extensions_path = data_dir_
       .AppendASCII("storage_quota");
 
   FilePath limited_quota_ext =
@@ skipping 1191 matching lines @@
   EXPECT_FALSE(extensions::HasExternalInstallError(service_));
   EXPECT_FALSE(service_->IsExtensionEnabled(good_crx));
   EXPECT_TRUE(service_->IsExtensionEnabled(page_action));
 
   ExtensionPrefs* prefs = service_->extension_prefs();
   EXPECT_NE(0, prefs->GetDisableReasons(good_crx) &
       Extension::DISABLE_SIDELOAD_WIPEOUT);
   EXPECT_EQ(0, prefs->GetDisableReasons(page_action) &
       Extension::DISABLE_SIDELOAD_WIPEOUT);
 }