Cleanup: Make namespace shell_integration_linux follow the style guide.

chrome/browser/shell_integration_linux.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/shell_integration_linux.h"
 
 #include <fcntl.h>
 
 #if defined(USE_GLIB)
 #include <glib.h>
@@ skipping 305 matching lines @@
 const char kXdgSettingsDefaultSchemeHandler[] = "default-url-scheme-handler";
 
 const char kDirectoryFilename[] = "chrome-apps.directory";
 
 #if defined(GOOGLE_CHROME_BUILD)
 const char kAppListDesktopName[] = "chrome-app-list";
 #else  // CHROMIUM_BUILD
 const char kAppListDesktopName[] = "chromium-app-list";
 #endif
 
-}  // namespace
-
-namespace {
-
 // Utility function to get the path to the version of a script shipped with
 // Chrome. |script| gives the name of the script. |chrome_version| returns the
 // path to the Chrome version of the script, and the return value of the
 // function is true if the function is successful and the Chrome version is
 // not the script found on the PATH.
 bool GetChromeVersionOfScript(const std::string& script,
-                               std::string* chrome_version) {
+                              std::string* chrome_version) {
   // Get the path to the Chrome version.
   base::FilePath chrome_dir;
   if (!PathService::Get(base::DIR_EXE, &chrome_dir))
     return false;
 
   base::FilePath chrome_version_path = chrome_dir.Append(script);
   *chrome_version = chrome_version_path.value();
 
   // Check if this is different to the one on path.
   std::vector<std::string> argv;
@@ skipping 32 matching lines @@
 
   std::vector<std::string> argv;
   argv.push_back(kXdgSettings);
   argv.push_back("set");
   if (protocol.empty()) {
     argv.push_back(kXdgSettingsDefaultBrowser);
   } else {
     argv.push_back(kXdgSettingsDefaultSchemeHandler);
     argv.push_back(protocol);
   }
-  argv.push_back(ShellIntegrationLinux::GetDesktopName(env.get()));
+  argv.push_back(shell_integration_linux::GetDesktopName(env.get()));
 
   int exit_code;
   bool ran_ok = LaunchXdgUtility(argv, &exit_code);
   if (ran_ok && exit_code == EXIT_XDG_SETTINGS_SYNTAX_ERROR) {
     if (GetChromeVersionOfScript(kXdgSettings, &argv[0])) {
       ran_ok = LaunchXdgUtility(argv, &exit_code);
     }
   }
 
   return ran_ok && exit_code == EXIT_SUCCESS;
@@ skipping 14 matching lines @@
 
   std::vector<std::string> argv;
   argv.push_back(kXdgSettings);
   argv.push_back("check");
   if (protocol.empty()) {
     argv.push_back(kXdgSettingsDefaultBrowser);
   } else {
     argv.push_back(kXdgSettingsDefaultSchemeHandler);
     argv.push_back(protocol);
   }
-  argv.push_back(ShellIntegrationLinux::GetDesktopName(env.get()));
+  argv.push_back(shell_integration_linux::GetDesktopName(env.get()));
 
   std::string reply;
   int success_code;
   bool ran_ok = base::GetAppOutputWithExitCode(CommandLine(argv), &reply,
                                                &success_code);
   if (ran_ok && success_code == EXIT_XDG_SETTINGS_SYNTAX_ERROR) {
     if (GetChromeVersionOfScript(kXdgSettings, &argv[0])) {
       ran_ok = base::GetAppOutputWithExitCode(CommandLine(argv), &reply,
                                               &success_code);
     }
@@ skipping 57 matching lines @@
   if (environment->GetVar("CHROME_WRAPPER", &wrapper_script)) {
     return base::FilePath(wrapper_script);
   }
 
   // Just return the name of the executable path for Chrome.
   base::FilePath chrome_exe_path;
   PathService::Get(base::FILE_EXE, &chrome_exe_path);
   return chrome_exe_path;
 }
 
-} // namespace
+}  // namespace
 
 // static
 ShellIntegration::DefaultWebClientSetPermission
-    ShellIntegration::CanSetAsDefaultBrowser() {
+ShellIntegration::CanSetAsDefaultBrowser() {
   return SET_DEFAULT_UNATTENDED;
 }
 
 // static
 bool ShellIntegration::SetAsDefaultBrowser() {
   return SetDefaultWebClient(std::string());
 }
 
 // static
-bool ShellIntegration::SetAsDefaultProtocolClient(const std::string& protocol) {
+bool ShellIntegration::SetAsDefaultProtocolClient(
+    const std::string& protocol) {
   return SetDefaultWebClient(protocol);
 }
 
 // static
-ShellIntegration::DefaultWebClientState ShellIntegration::GetDefaultBrowser() {
+ShellIntegration::DefaultWebClientState
+ShellIntegration::GetDefaultBrowser() {
   return GetIsDefaultWebClient(std::string());
 }
 
 // static
 base::string16 ShellIntegration::GetApplicationNameForProtocol(
     const GURL& url) {
   return base::ASCIIToUTF16("xdg-open");
 }
 
 // static
 ShellIntegration::DefaultWebClientState
 ShellIntegration::IsDefaultProtocolClient(const std::string& protocol) {
   return GetIsDefaultWebClient(protocol);
 }
 
 // static
 bool ShellIntegration::IsFirefoxDefaultBrowser() {
   std::vector<std::string> argv;
   argv.push_back(kXdgSettings);
   argv.push_back("get");
   argv.push_back(kXdgSettingsDefaultBrowser);
 
   std::string browser;
   // We don't care about the return value here.
   base::GetAppOutput(CommandLine(argv), &browser);
   return browser.find("irefox") != std::string::npos;
 }
 
-namespace ShellIntegrationLinux {
+namespace shell_integration_linux {
 
 bool GetDataWriteLocation(base::Environment* env, base::FilePath* search_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::string xdg_data_home;
   std::string home;
   if (env->GetVar("XDG_DATA_HOME", &xdg_data_home) && !xdg_data_home.empty()) {
     *search_path = base::FilePath(xdg_data_home);
     return true;
   } else if (env->GetVar("HOME", &home) && !home.empty()) {
@@ skipping 288 matching lines @@
     } else {
       output_buffer += data_dump;
     }
     g_free(data_dump);
   }
 
   g_key_file_free(key_file);
   return output_buffer;
 #else
   NOTIMPLEMENTED();
-  return std::string("");
+  return std::string();
 #endif
 }
 
 std::string GetDirectoryFileContents(const base::string16& title,
                                      const std::string& icon_name) {
 #if defined(USE_GLIB)
   // See http://standards.freedesktop.org/desktop-entry-spec/latest/
   GKeyFile* key_file = g_key_file_new();
 
   g_key_file_set_string(key_file, kDesktopEntry, "Version", "1.0");
@@ skipping 19 matching lines @@
     } else {
       output_buffer += data_dump;
     }
     g_free(data_dump);
   }
 
   g_key_file_free(key_file);
   return output_buffer;
 #else
   NOTIMPLEMENTED();
-  return std::string("");
+  return std::string();
 #endif
 }
 
 bool CreateDesktopShortcut(
     const web_app::ShortcutInfo& shortcut_info,
     const web_app::ShortcutLocations& creation_locations) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   base::FilePath shortcut_filename;
   if (!shortcut_info.extension_id.empty()) {
@@ skipping 23 matching lines @@
 
   bool success = true;
 
   base::FilePath chrome_exe_path = GetChromeExePath();
   if (chrome_exe_path.empty()) {
     LOG(WARNING) << "Could not get executable path.";
     return false;
   }
 
   if (creation_locations.on_desktop) {
-    std::string contents = ShellIntegrationLinux::GetDesktopFileContents(
+    std::string contents = GetDesktopFileContents(
         chrome_exe_path,
         app_name,
         shortcut_info.url,
         shortcut_info.extension_id,
         shortcut_info.title,
         icon_name,
         shortcut_info.profile_path,
         "",
         false);
     success = CreateShortcutOnDesktop(shortcut_filename, contents);
   }
 
   if (creation_locations.applications_menu_location !=
           web_app::APP_MENU_LOCATION_NONE ||
       creation_locations.hidden) {
     base::FilePath directory_filename;
     std::string directory_contents;
     switch (creation_locations.applications_menu_location) {
       case web_app::APP_MENU_LOCATION_NONE:
       case web_app::APP_MENU_LOCATION_ROOT:
         break;
       case web_app::APP_MENU_LOCATION_SUBDIR_CHROMEAPPS:
         directory_filename = base::FilePath(kDirectoryFilename);
-        directory_contents = ShellIntegrationLinux::GetDirectoryFileContents(
+        directory_contents = GetDirectoryFileContents(
             ShellIntegration::GetAppShortcutsSubdirName(), "");
         break;
       default:
         NOTREACHED();
         break;
     }
     // Set NoDisplay=true if hidden but not in the applications menu. This will
     // hide the application from user-facing menus.
-    std::string contents = ShellIntegrationLinux::GetDesktopFileContents(
+    std::string contents = GetDesktopFileContents(
         chrome_exe_path,
         app_name,
         shortcut_info.url,
         shortcut_info.extension_id,
         shortcut_info.title,
         icon_name,
         shortcut_info.profile_path,
         "",
         creation_locations.applications_menu_location ==
             web_app::APP_MENU_LOCATION_NONE);
@@ skipping 87 matching lines @@
         GetExistingProfileShortcutFilenames(profile_path, applications_menu);
     for (std::vector<base::FilePath>::const_iterator it =
          shortcut_filenames_app_menu.begin();
          it != shortcut_filenames_app_menu.end(); ++it) {
       DeleteShortcutInApplicationsMenu(*it,
                                        base::FilePath(kDirectoryFilename));
     }
   }
 }
 
-}  // namespace ShellIntegrationLinux
+}  // namespace shell_integration_linux