Make callers of CommandLine use it via the base:: namespace.

chrome/browser/background/background_mode_manager_unittest.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/background/background_mode_manager.h"
 #include "chrome/browser/browser_shutdown.h"
@@ skipping 20 matching lines @@
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
 namespace {
 
 // Helper class that tracks state transitions in BackgroundModeManager and
 // exposes them via getters.
 class SimpleTestBackgroundModeManager : public BackgroundModeManager {
  public:
-  SimpleTestBackgroundModeManager(
-      CommandLine* command_line, ProfileInfoCache* cache)
+  SimpleTestBackgroundModeManager(base::CommandLine* command_line,
+                                  ProfileInfoCache* cache)
       : BackgroundModeManager(command_line, cache),
         have_status_tray_(false),
         launch_on_startup_(false),
         has_shown_balloon_(false) {
     ResumeBackgroundMode();
   }
 
   void EnableLaunchOnStartup(bool launch) override {
     launch_on_startup_ = launch;
   }
@@ skipping 33 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestStatusIcon);
 };
 
 } // namespace
 
 // More complex test helper that exposes APIs for fine grained control of
 // things like the number of background applications. This allows writing
 // smaller tests that don't have to install/uninstall extensions.
 class TestBackgroundModeManager : public SimpleTestBackgroundModeManager {
  public:
-  TestBackgroundModeManager(
-      CommandLine* command_line, ProfileInfoCache* cache, bool enabled)
+  TestBackgroundModeManager(base::CommandLine* command_line,
+                            ProfileInfoCache* cache,
+                            bool enabled)
       : SimpleTestBackgroundModeManager(command_line, cache),
         enabled_(enabled),
         app_count_(0),
         profile_app_count_(0) {
     ResumeBackgroundMode();
   }
 
   int GetBackgroundAppCount() const override { return app_count_; }
   int GetBackgroundAppCountForProfile(Profile* const profile) const override {
     return profile_app_count_;
@@ skipping 39 matching lines @@
   EXPECT_TRUE(manager.IsLaunchOnStartup());
 }
 
 } // namespace
 
 class BackgroundModeManagerTest : public testing::Test {
  public:
   BackgroundModeManagerTest() {}
   ~BackgroundModeManagerTest() override {}
   void SetUp() override {
-    command_line_.reset(new CommandLine(CommandLine::NO_PROGRAM));
+    command_line_.reset(new base::CommandLine(base::CommandLine::NO_PROGRAM));
     profile_manager_ = CreateTestingProfileManager();
     profile_ = profile_manager_->CreateTestingProfile("p1");
   }
-  scoped_ptr<CommandLine> command_line_;
+  scoped_ptr<base::CommandLine> command_line_;
 
  protected:
   scoped_refptr<extensions::Extension> CreateExtension(
       extensions::Manifest::Location location,
       const std::string& data,
       const std::string& id) {
     scoped_ptr<base::DictionaryValue> parsed_manifest(
         extension_function_test_utils::ParseDictionary(data));
     return extension_function_test_utils::CreateExtension(
         location,
@@ skipping 417 matching lines @@
     CreateExtension(
         extensions::Manifest::COMMAND_LINE,
         "{\"name\": \"Regular Extension with Options\","
         "\"version\": \"1.0\","
         "\"manifest_version\": 2,"
         "\"permissions\": [\"background\"],"
         "\"options_page\": \"test.html\"}",
         "ID-4"));
 
   static_cast<extensions::TestExtensionSystem*>(
-      extensions::ExtensionSystem::Get(profile_))->CreateExtensionService(
-          CommandLine::ForCurrentProcess(),
-          base::FilePath(),
-          false);
+      extensions::ExtensionSystem::Get(profile_))
+      ->CreateExtensionService(base::CommandLine::ForCurrentProcess(),
+                               base::FilePath(), false);
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   service->Init();
 
   service->AddComponentExtension(component_extension.get());
   service->AddComponentExtension(component_extension_with_options.get());
   service->AddExtension(regular_extension.get());
   service->AddExtension(regular_extension_with_options.get());
 
   scoped_ptr<StatusIconMenuModel> menu(new StatusIconMenuModel(NULL));
@@ skipping 54 matching lines @@
     CreateExtension(
         extensions::Manifest::COMMAND_LINE,
         "{\"name\": \"Regular Extension with Options\","
         "\"version\": \"1.0\","
         "\"manifest_version\": 2,"
         "\"permissions\": [\"background\"],"
         "\"options_page\": \"test.html\"}",
         "ID-4"));
 
   static_cast<extensions::TestExtensionSystem*>(
-      extensions::ExtensionSystem::Get(profile_))->CreateExtensionService(
-          CommandLine::ForCurrentProcess(),
-          base::FilePath(),
-          false);
+      extensions::ExtensionSystem::Get(profile_))
+      ->CreateExtensionService(base::CommandLine::ForCurrentProcess(),
+                               base::FilePath(), false);
   ExtensionService* service1 =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   service1->Init();
 
   service1->AddComponentExtension(component_extension.get());
   service1->AddComponentExtension(component_extension_with_options.get());
   service1->AddExtension(regular_extension.get());
   service1->AddExtension(regular_extension_with_options.get());
 
   static_cast<extensions::TestExtensionSystem*>(
-      extensions::ExtensionSystem::Get(profile2))->CreateExtensionService(
-          CommandLine::ForCurrentProcess(),
-          base::FilePath(),
-          false);
+      extensions::ExtensionSystem::Get(profile2))
+      ->CreateExtensionService(base::CommandLine::ForCurrentProcess(),
+                               base::FilePath(), false);
   ExtensionService* service2 =
       extensions::ExtensionSystem::Get(profile2)->extension_service();
   service2->Init();
 
   service2->AddComponentExtension(component_extension.get());
   service2->AddExtension(regular_extension.get());
   service2->AddExtension(regular_extension_with_options.get());
 
   manager_->RegisterProfile(profile2);
 
@@ skipping 128 matching lines @@
   scoped_refptr<extensions::Extension> ephemeral_app(
     CreateExtension(
         extensions::Manifest::COMMAND_LINE,
         "{\"name\": \"Ephemeral App\", "
         "\"version\": \"1.0\","
         "\"manifest_version\": 2,"
         "\"permissions\": [\"pushMessaging\"]}",
         "ID-3"));
 
   static_cast<extensions::TestExtensionSystem*>(
-      extensions::ExtensionSystem::Get(profile_))->CreateExtensionService(
-          CommandLine::ForCurrentProcess(),
-          base::FilePath(),
-          false);
+      extensions::ExtensionSystem::Get(profile_))
+      ->CreateExtensionService(base::CommandLine::ForCurrentProcess(),
+                               base::FilePath(), false);
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   DCHECK(!service->is_ready());
   service->Init();
   DCHECK(service->is_ready());
   manager_->status_icon_ = new TestStatusIcon();
   manager_->UpdateStatusTrayIconContextMenu();
 
   // Adding a background extension should show the balloon.
@@ skipping 18 matching lines @@
   // Installing an ephemeral app should not show the balloon.
   manager_->SetHasShownBalloon(false);
   AddEphemeralApp(ephemeral_app.get(), service);
   EXPECT_FALSE(manager_->HasShownBalloon());
 
   // Promoting the ephemeral app to a regular installed app should now show
   // the balloon.
   service->PromoteEphemeralApp(ephemeral_app.get(), false /*from sync*/);
   EXPECT_TRUE(manager_->HasShownBalloon());
 }