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/files/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 31using content::BrowserThread; 32 33ShellIntegration::DefaultWebClientSetPermission 34 ShellIntegration::CanSetAsDefaultProtocolClient() { 35 // Allowed as long as the browser can become the operating system default 36 // browser. 37 return CanSetAsDefaultBrowser(); 38} 39 40static const struct ShellIntegration::AppModeInfo* gAppModeInfo = NULL; 41 42// static 43void ShellIntegration::SetAppModeInfo(const struct AppModeInfo* info) { 44 gAppModeInfo = info; 45} 46 47// static 48const struct ShellIntegration::AppModeInfo* ShellIntegration::AppModeInfo() { 49 return gAppModeInfo; 50} 51 52// static 53bool ShellIntegration::IsRunningInAppMode() { 54 return gAppModeInfo != NULL; 55} 56 57// static 58CommandLine 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 84void 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 117base::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 124bool ShellIntegration::SetAsDefaultBrowserInteractive() { 125 return false; 126} 127 128// static 129bool ShellIntegration::SetAsDefaultProtocolClientInteractive( 130 const std::string& protocol) { 131 return false; 132} 133#endif 134 135bool ShellIntegration::DefaultWebClientObserver::IsOwnedByWorker() { 136 return false; 137} 138 139bool ShellIntegration::DefaultWebClientObserver:: 140 IsInteractiveSetDefaultPermitted() { 141 return false; 142} 143 144/////////////////////////////////////////////////////////////////////////////// 145// ShellIntegration::DefaultWebClientWorker 146// 147 148ShellIntegration::DefaultWebClientWorker::DefaultWebClientWorker( 149 DefaultWebClientObserver* observer) 150 : observer_(observer) { 151} 152 153void 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 163void 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 175void 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 185void 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 194void 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 206void 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 216void 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 226void 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 249ShellIntegration::DefaultBrowserWorker::DefaultBrowserWorker( 250 DefaultWebClientObserver* observer) 251 : DefaultWebClientWorker(observer) { 252} 253 254/////////////////////////////////////////////////////////////////////////////// 255// DefaultBrowserWorker, private: 256 257ShellIntegration::DefaultWebClientState 258ShellIntegration::DefaultBrowserWorker::CheckIsDefault() { 259 return ShellIntegration::GetDefaultBrowser(); 260} 261 262bool 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 284ShellIntegration::DefaultProtocolClientWorker::DefaultProtocolClientWorker( 285 DefaultWebClientObserver* observer, const std::string& protocol) 286 : DefaultWebClientWorker(observer), 287 protocol_(protocol) { 288} 289 290/////////////////////////////////////////////////////////////////////////////// 291// DefaultProtocolClientWorker, private: 292 293ShellIntegration::DefaultWebClientState 294ShellIntegration::DefaultProtocolClientWorker::CheckIsDefault() { 295 return ShellIntegration::IsDefaultProtocolClient(protocol_); 296} 297 298bool 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} 318