chrome/browser/shell_integration.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/shell_integration.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "base/file_util.h"
  10 #include "base/path_service.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/threading/thread_restrictions.h"
  15 #include "chrome/browser/policy/policy_path_parser.h"
  16 #include "chrome/common/chrome_paths.h"
  17 #include "chrome/common/chrome_switches.h"
  18 #include "chrome/common/pref_names.h"
  19 #include "content/public/browser/browser_thread.h"
  20
  21 #if defined(OS_CHROMEOS)
  22 #include "chromeos/chromeos_switches.h"
  23 #endif
  24
  25 #if !defined(OS_WIN)
  26 #include "chrome/common/chrome_version_info.h"
  27 #include "grit/chromium_strings.h"
  28 #include "ui/base/l10n/l10n_util.h"
  29 #endif
  30
  31 using content::BrowserThread;
  32
  33 ShellIntegration::DefaultWebClientSetPermission
  34     ShellIntegration::CanSetAsDefaultProtocolClient() {
  35   // Allowed as long as the browser can become the operating system default
  36   // browser.
  37   return CanSetAsDefaultBrowser();
  38 }
  39
  40 ShellIntegration::ShortcutInfo::ShortcutInfo()
  41     : is_platform_app(false) {
  42 }
  43
  44 ShellIntegration::ShortcutInfo::~ShortcutInfo() {}
  45
  46 ShellIntegration::ShortcutLocations::ShortcutLocations()
  47     : on_desktop(false),
  48       applications_menu_location(APP_MENU_LOCATION_NONE),
  49       in_quick_launch_bar(false)
  50 #if defined(OS_POSIX)
  51       , hidden(false)
  52 #endif
  53       {
  54 }
  55
  56 static const struct ShellIntegration::AppModeInfo* gAppModeInfo = NULL;
  57
  58 // static
  59 void ShellIntegration::SetAppModeInfo(const struct AppModeInfo* info) {
  60   gAppModeInfo = info;
  61 }
  62
  63 // static
  64 const struct ShellIntegration::AppModeInfo* ShellIntegration::AppModeInfo() {
  65   return gAppModeInfo;
  66 }
  67
  68 // static
  69 bool ShellIntegration::IsRunningInAppMode() {
  70   return gAppModeInfo != NULL;
  71 }
  72
  73 // static
  74 CommandLine ShellIntegration::CommandLineArgsForLauncher(
  75     const GURL& url,
  76     const std::string& extension_app_id,
  77     const base::FilePath& profile_path) {
  78   base::ThreadRestrictions::AssertIOAllowed();
  79   const CommandLine& cmd_line = *CommandLine::ForCurrentProcess();
  80   CommandLine new_cmd_line(CommandLine::NO_PROGRAM);
  81
  82   // Use the same UserDataDir for new launches that we currently have set.
  83   base::FilePath user_data_dir =
  84       cmd_line.GetSwitchValuePath(switches::kUserDataDir);
  85 #if defined(OS_MACOSX) || defined(OS_WIN)
  86   policy::path_parser::CheckUserDataDirPolicy(&user_data_dir);
  87 #endif
  88   if (!user_data_dir.empty()) {
  89     // Make sure user_data_dir is an absolute path.
  90     user_data_dir = base::MakeAbsoluteFilePath(user_data_dir);
  91     if (!user_data_dir.empty() && base::PathExists(user_data_dir))
  92       new_cmd_line.AppendSwitchPath(switches::kUserDataDir, user_data_dir);
  93   }
  94
  95 #if defined(OS_CHROMEOS)
  96   base::FilePath profile = cmd_line.GetSwitchValuePath(
  97       chromeos::switches::kLoginProfile);
  98   if (!profile.empty())
  99     new_cmd_line.AppendSwitchPath(chromeos::switches::kLoginProfile, profile);
 100 #else
 101   if (!profile_path.empty() && !extension_app_id.empty())
 102     new_cmd_line.AppendSwitchPath(switches::kProfileDirectory,
 103                                   profile_path.BaseName());
 104 #endif
 105
 106   // If |extension_app_id| is present, we use the kAppId switch rather than
 107   // the kApp switch (the launch url will be read from the extension app
 108   // during launch.
 109   if (!extension_app_id.empty()) {
 110     new_cmd_line.AppendSwitchASCII(switches::kAppId, extension_app_id);
 111   } else {
 112     // Use '--app=url' instead of just 'url' to launch the browser with minimal
 113     // chrome.
 114     // Note: Do not change this flag!  Old Gears shortcuts will break if you do!
 115     new_cmd_line.AppendSwitchASCII(switches::kApp, url.spec());
 116   }
 117   return new_cmd_line;
 118 }
 119
 120 #if !defined(OS_WIN)
 121
 122 base::string16 ShellIntegration::GetAppShortcutsSubdirName() {
 123   if (chrome::VersionInfo::GetChannel() == chrome::VersionInfo::CHANNEL_CANARY)
 124     return l10n_util::GetStringUTF16(IDS_APP_SHORTCUTS_SUBDIR_NAME_CANARY);
 125   return l10n_util::GetStringUTF16(IDS_APP_SHORTCUTS_SUBDIR_NAME);
 126 }
 127
 128 // static
 129 bool ShellIntegration::SetAsDefaultBrowserInteractive() {
 130   return false;
 131 }
 132
 133 // static
 134 bool ShellIntegration::SetAsDefaultProtocolClientInteractive(
 135     const std::string& protocol) {
 136   return false;
 137 }
 138 #endif
 139
 140 bool ShellIntegration::DefaultWebClientObserver::IsOwnedByWorker() {
 141   return false;
 142 }
 143
 144 bool ShellIntegration::DefaultWebClientObserver::
 145     IsInteractiveSetDefaultPermitted() {
 146   return false;
 147 }
 148
 149 ///////////////////////////////////////////////////////////////////////////////
 150 // ShellIntegration::DefaultWebClientWorker
 151 //
 152
 153 ShellIntegration::DefaultWebClientWorker::DefaultWebClientWorker(
 154     DefaultWebClientObserver* observer)
 155     : observer_(observer) {
 156 }
 157
 158 void ShellIntegration::DefaultWebClientWorker::StartCheckIsDefault() {
 159   if (observer_) {
 160     observer_->SetDefaultWebClientUIState(STATE_PROCESSING);
 161     BrowserThread::PostTask(
 162         BrowserThread::FILE, FROM_HERE,
 163         base::Bind(
 164             &DefaultWebClientWorker::ExecuteCheckIsDefault, this));
 165   }
 166 }
 167
 168 void ShellIntegration::DefaultWebClientWorker::StartSetAsDefault() {
 169   bool interactive_permitted = false;
 170   if (observer_) {
 171     observer_->SetDefaultWebClientUIState(STATE_PROCESSING);
 172     interactive_permitted = observer_->IsInteractiveSetDefaultPermitted();
 173   }
 174   BrowserThread::PostTask(
 175       BrowserThread::FILE, FROM_HERE,
 176       base::Bind(&DefaultWebClientWorker::ExecuteSetAsDefault, this,
 177                  interactive_permitted));
 178 }
 179
 180 void ShellIntegration::DefaultWebClientWorker::ObserverDestroyed() {
 181   // Our associated view has gone away, so we shouldn't call back to it if
 182   // our worker thread returns after the view is dead.
 183   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 184   observer_ = NULL;
 185 }
 186
 187 ///////////////////////////////////////////////////////////////////////////////
 188 // DefaultWebClientWorker, private:
 189
 190 void ShellIntegration::DefaultWebClientWorker::ExecuteCheckIsDefault() {
 191   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 192   DefaultWebClientState state = CheckIsDefault();
 193   BrowserThread::PostTask(
 194       BrowserThread::UI, FROM_HERE,
 195       base::Bind(
 196           &DefaultWebClientWorker::CompleteCheckIsDefault, this, state));
 197 }
 198
 199 void ShellIntegration::DefaultWebClientWorker::CompleteCheckIsDefault(
 200     DefaultWebClientState state) {
 201   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 202   UpdateUI(state);
 203   // The worker has finished everything it needs to do, so free the observer
 204   // if we own it.
 205   if (observer_ && observer_->IsOwnedByWorker()) {
 206     delete observer_;
 207     observer_ = NULL;
 208   }
 209 }
 210
 211 void ShellIntegration::DefaultWebClientWorker::ExecuteSetAsDefault(
 212     bool interactive_permitted) {
 213   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 214
 215   bool result = SetAsDefault(interactive_permitted);
 216   BrowserThread::PostTask(
 217       BrowserThread::UI, FROM_HERE,
 218       base::Bind(&DefaultWebClientWorker::CompleteSetAsDefault, this, result));
 219 }
 220
 221 void ShellIntegration::DefaultWebClientWorker::CompleteSetAsDefault(
 222     bool succeeded) {
 223   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 224   // First tell the observer what the SetAsDefault call has returned.
 225   if (observer_)
 226     observer_->OnSetAsDefaultConcluded(succeeded);
 227   // Set as default completed, check again to make sure it stuck...
 228   StartCheckIsDefault();
 229 }
 230
 231 void ShellIntegration::DefaultWebClientWorker::UpdateUI(
 232     DefaultWebClientState state) {
 233   if (observer_) {
 234     switch (state) {
 235       case NOT_DEFAULT:
 236         observer_->SetDefaultWebClientUIState(STATE_NOT_DEFAULT);
 237         break;
 238       case IS_DEFAULT:
 239         observer_->SetDefaultWebClientUIState(STATE_IS_DEFAULT);
 240         break;
 241       case UNKNOWN_DEFAULT:
 242         observer_->SetDefaultWebClientUIState(STATE_UNKNOWN);
 243         break;
 244       default:
 245         break;
 246     }
 247   }
 248 }
 249
 250 ///////////////////////////////////////////////////////////////////////////////
 251 // ShellIntegration::DefaultBrowserWorker
 252 //
 253
 254 ShellIntegration::DefaultBrowserWorker::DefaultBrowserWorker(
 255     DefaultWebClientObserver* observer)
 256     : DefaultWebClientWorker(observer) {
 257 }
 258
 259 ///////////////////////////////////////////////////////////////////////////////
 260 // DefaultBrowserWorker, private:
 261
 262 ShellIntegration::DefaultWebClientState
 263 ShellIntegration::DefaultBrowserWorker::CheckIsDefault() {
 264   return ShellIntegration::GetDefaultBrowser();
 265 }
 266
 267 bool ShellIntegration::DefaultBrowserWorker::SetAsDefault(
 268     bool interactive_permitted) {
 269   bool result = false;
 270   switch (ShellIntegration::CanSetAsDefaultBrowser()) {
 271     case ShellIntegration::SET_DEFAULT_UNATTENDED:
 272       result = ShellIntegration::SetAsDefaultBrowser();
 273       break;
 274     case ShellIntegration::SET_DEFAULT_INTERACTIVE:
 275       if (interactive_permitted)
 276         result = ShellIntegration::SetAsDefaultBrowserInteractive();
 277       break;
 278     default:
 279       NOTREACHED();
 280   }
 281
 282   return result;
 283 }
 284
 285 ///////////////////////////////////////////////////////////////////////////////
 286 // ShellIntegration::DefaultProtocolClientWorker
 287 //
 288
 289 ShellIntegration::DefaultProtocolClientWorker::DefaultProtocolClientWorker(
 290     DefaultWebClientObserver* observer, const std::string& protocol)
 291     : DefaultWebClientWorker(observer),
 292       protocol_(protocol) {
 293 }
 294
 295 ///////////////////////////////////////////////////////////////////////////////
 296 // DefaultProtocolClientWorker, private:
 297
 298 ShellIntegration::DefaultWebClientState
 299 ShellIntegration::DefaultProtocolClientWorker::CheckIsDefault() {
 300   return ShellIntegration::IsDefaultProtocolClient(protocol_);
 301 }
 302
 303 bool ShellIntegration::DefaultProtocolClientWorker::SetAsDefault(
 304     bool interactive_permitted) {
 305   bool result = false;
 306   switch (ShellIntegration::CanSetAsDefaultProtocolClient()) {
 307     case ShellIntegration::SET_DEFAULT_NOT_ALLOWED:
 308       result = false;
 309       break;
 310     case ShellIntegration::SET_DEFAULT_UNATTENDED:
 311       result = ShellIntegration::SetAsDefaultProtocolClient(protocol_);
 312       break;
 313     case ShellIntegration::SET_DEFAULT_INTERACTIVE:
 314       if (interactive_permitted) {
 315         result = ShellIntegration::SetAsDefaultProtocolClientInteractive(
 316             protocol_);
 317       }
 318       break;
 319   }
 320
 321   return result;
 322 }