Moved Linux specific shell integration declarations into own header.

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>
 #include <glib.h>
 #include <stdlib.h>
 #include <sys/stat.h>
@@ skipping 214 matching lines @@
 const char kDesktopEntry[] = "Desktop Entry";
 
 const char kXdgOpenShebang[] = "#!/usr/bin/env xdg-open";
 
 const char kXdgSettings[] = "xdg-settings";
 const char kXdgSettingsDefaultBrowser[] = "default-web-browser";
 const char kXdgSettingsDefaultSchemeHandler[] = "default-url-scheme-handler";
 
 }  // namespace
 
-// static
-std::string ShellIntegration::GetDesktopName(base::Environment* env) {
-#if defined(GOOGLE_CHROME_BUILD)
-  return "google-chrome.desktop";
-#else  // CHROMIUM_BUILD
-  // Allow $CHROME_DESKTOP to override the built-in value, so that development
-  // versions can set themselves as the default without interfering with
-  // non-official, packaged versions using the built-in value.
-  std::string name;
-  if (env->GetVar("CHROME_DESKTOP", &name) && !name.empty())
-    return name;
-  return "chromium-browser.desktop";
-#endif
-}
-
 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) {
   // Get the path to the Chrome version.
@@ skipping 40 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(ShellIntegration::GetDesktopName(env.get()));
+  argv.push_back(ShellIntegrationLinux::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 10 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(ShellIntegration::GetDesktopName(env.get()));
+  argv.push_back(ShellIntegrationLinux::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 43 matching lines @@
   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;
 }
 
-// static
-bool ShellIntegration::GetDesktopShortcutTemplate(
-    base::Environment* env, std::string* output) {
+namespace ShellIntegrationLinux {
+
+std::string GetDesktopName(base::Environment* env) {
+#if defined(GOOGLE_CHROME_BUILD)
+  return "google-chrome.desktop";
+#else  // CHROMIUM_BUILD
+  // Allow $CHROME_DESKTOP to override the built-in value, so that development
+  // versions can set themselves as the default without interfering with
+  // non-official, packaged versions using the built-in value.
+  std::string name;
+  if (env->GetVar("CHROME_DESKTOP", &name) && !name.empty())
+    return name;
+  return "chromium-browser.desktop";
+#endif
+}
+
+bool GetDesktopShortcutTemplate(base::Environment* env,
+                                std::string* output) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::vector<FilePath> search_paths;
 
   std::string xdg_data_home;
   if (env->GetVar("XDG_DATA_HOME", &xdg_data_home) &&
       !xdg_data_home.empty()) {
     search_paths.push_back(FilePath(xdg_data_home));
   }
 
@@ skipping 21 matching lines @@
     if (file_util::PathExists(path)) {
       VLOG(1) << "Found desktop file template at " << path.value();
       return file_util::ReadFileToString(path, output);
     }
   }
 
   LOG(ERROR) << "Could not find desktop file template.";
   return false;
 }
 
-// static
-FilePath ShellIntegration::GetDesktopShortcutFilename(const GURL& url) {
+FilePath GetDesktopShortcutFilename(const GURL& url) {
   // Use a prefix, because xdg-desktop-menu requires it.
   std::string filename =
       std::string(chrome::kBrowserProcessExecutableName) + "-" + url.spec();
   file_util::ReplaceIllegalCharactersInPath(&filename, '_');
 
   FilePath desktop_path;
   if (!PathService::Get(chrome::DIR_USER_DESKTOP, &desktop_path))
     return FilePath();
 
   FilePath filepath = desktop_path.Append(filename);
   FilePath alternative_filepath(filepath.value() + ".desktop");
   for (size_t i = 1; i < 100; ++i) {
     if (file_util::PathExists(FilePath(alternative_filepath))) {
       alternative_filepath = FilePath(
           filepath.value() + "_" + base::IntToString(i) + ".desktop");
     } else {
       return FilePath(alternative_filepath).BaseName();
     }
   }
 
   return FilePath();
 }
 
-// static
-std::string ShellIntegration::GetDesktopFileContents(
+std::string GetDesktopFileContents(
     const std::string& template_contents,
     const std::string& app_name,
     const GURL& url,
     const std::string& extension_id,
     const bool is_platform_app,
     const FilePath& web_app_path,
     const FilePath& extension_path,
     const string16& title,
     const std::string& icon_name) {
   if (template_contents.empty())
@@ skipping 97 matching lines @@
   gchar* data_dump = g_key_file_to_data(key_file, &length, NULL);
   if (data_dump) {
     output_buffer += data_dump;
     g_free(data_dump);
   }
 
   g_key_file_free(key_file);
   return output_buffer;
 }
 
-// static
-bool ShellIntegration::CreateDesktopShortcut(
-    const ShortcutInfo& shortcut_info,
+bool CreateDesktopShortcut(
+    const ShellIntegration::ShortcutInfo& shortcut_info,
     const std::string& shortcut_template) {
   DCHECK(!shortcut_info.is_platform_app);
   DCHECK(shortcut_info.extension_id.empty());
 
   return ShellIntegrationLinux::CreateDesktopShortcutForChromeApp(
       shortcut_info, FilePath(), shortcut_template);
 }
 
-namespace ShellIntegrationLinux {
-
 bool CreateDesktopShortcutForChromeApp(
     const ShellIntegration::ShortcutInfo& shortcut_info,
     const FilePath& web_app_path,
     const std::string& shortcut_template) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  FilePath shortcut_filename = ShellIntegration::GetDesktopShortcutFilename(
-      shortcut_info.url);
+  FilePath shortcut_filename =
+      ShellIntegrationLinux::GetDesktopShortcutFilename(shortcut_info.url);
   if (shortcut_filename.empty())
     return false;
 
-  std::string icon_name = CreateShortcutIcon(shortcut_info, shortcut_filename);
+  std::string icon_name =CreateShortcutIcon(shortcut_info, shortcut_filename);
 
   std::string app_name =
       web_app::GenerateApplicationNameFromInfo(shortcut_info);
-  std::string contents = ShellIntegration::GetDesktopFileContents(
+  std::string contents = ShellIntegrationLinux::GetDesktopFileContents(
       shortcut_template,
       app_name,
       shortcut_info.url,
       shortcut_info.extension_id,
       shortcut_info.is_platform_app,
       web_app_path,
       shortcut_info.extension_path,
       shortcut_info.title,
       icon_name);
 
   bool success = true;
 
   if (shortcut_info.create_on_desktop)
     success = CreateShortcutOnDesktop(shortcut_filename, contents);
 
   if (shortcut_info.create_in_applications_menu)
     success = CreateShortcutInApplicationsMenu(shortcut_filename, contents) &&
               success;
 
   return success;
 }
 
 }  // namespace ShellIntegrationLinux