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