apps/app_shim/extension_app_shim_handler_mac.cc

   1 // Copyright 2013 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 "apps/app_shim/extension_app_shim_handler_mac.h"
   6
   7 #include "apps/app_lifetime_monitor_factory.h"
   8 #include "apps/app_shim/app_shim_host_manager_mac.h"
   9 #include "apps/app_shim/app_shim_messages.h"
  10 #include "apps/app_window.h"
  11 #include "apps/app_window_registry.h"
  12 #include "apps/launcher.h"
  13 #include "base/files/file_path.h"
  14 #include "base/logging.h"
  15 #include "chrome/browser/browser_process.h"
  16 #include "chrome/browser/chrome_notification_types.h"
  17 #include "chrome/browser/profiles/profile.h"
  18 #include "chrome/browser/profiles/profile_manager.h"
  19 #include "chrome/browser/ui/extensions/extension_enable_flow.h"
  20 #include "chrome/browser/ui/extensions/extension_enable_flow_delegate.h"
  21 #include "chrome/browser/ui/webui/ntp/core_app_launcher_handler.h"
  22 #include "chrome/browser/web_applications/web_app_mac.h"
  23 #include "chrome/common/extensions/extension_constants.h"
  24 #include "components/crx_file/id_util.h"
  25 #include "content/public/browser/notification_details.h"
  26 #include "content/public/browser/notification_service.h"
  27 #include "content/public/browser/notification_source.h"
  28 #include "extensions/browser/app_window/native_app_window.h"
  29 #include "extensions/browser/extension_host.h"
  30 #include "extensions/browser/extension_registry.h"
  31 #include "ui/base/cocoa/focus_window_set.h"
  32
  33 using extensions::ExtensionRegistry;
  34
  35 namespace {
  36
  37 typedef apps::AppWindowRegistry::AppWindowList AppWindowList;
  38
  39 void ProfileLoadedCallback(base::Callback<void(Profile*)> callback,
  40                            Profile* profile,
  41                            Profile::CreateStatus status) {
  42   if (status == Profile::CREATE_STATUS_INITIALIZED) {
  43     callback.Run(profile);
  44     return;
  45   }
  46
  47   // This should never get an error since it only loads existing profiles.
  48   DCHECK_EQ(Profile::CREATE_STATUS_CREATED, status);
  49 }
  50
  51 void SetAppHidden(Profile* profile, const std::string& app_id, bool hidden) {
  52   AppWindowList windows =
  53       apps::AppWindowRegistry::Get(profile)->GetAppWindowsForApp(app_id);
  54   for (AppWindowList::const_reverse_iterator it = windows.rbegin();
  55        it != windows.rend();
  56        ++it) {
  57     if (hidden)
  58       (*it)->GetBaseWindow()->HideWithApp();
  59     else
  60       (*it)->GetBaseWindow()->ShowWithApp();
  61   }
  62 }
  63
  64 bool FocusWindows(const AppWindowList& windows) {
  65   if (windows.empty())
  66     return false;
  67
  68   std::set<gfx::NativeWindow> native_windows;
  69   for (AppWindowList::const_iterator it = windows.begin(); it != windows.end();
  70        ++it) {
  71     native_windows.insert((*it)->GetNativeWindow());
  72   }
  73   // Allow workspace switching. For the browser process, we can reasonably rely
  74   // on OS X to switch spaces for us and honor relevant user settings. But shims
  75   // don't have windows, so we have to do it ourselves.
  76   ui::FocusWindowSet(native_windows);
  77   return true;
  78 }
  79
  80 // Attempts to launch a packaged app, prompting the user to enable it if
  81 // necessary. The prompt is shown in its own window.
  82 // This class manages its own lifetime.
  83 class EnableViaPrompt : public ExtensionEnableFlowDelegate {
  84  public:
  85   EnableViaPrompt(Profile* profile,
  86                   const std::string& extension_id,
  87                   const base::Callback<void()>& callback)
  88       : profile_(profile),
  89         extension_id_(extension_id),
  90         callback_(callback) {
  91   }
  92
  93   virtual ~EnableViaPrompt() {
  94   }
  95
  96   void Run() {
  97     flow_.reset(new ExtensionEnableFlow(profile_, extension_id_, this));
  98     flow_->StartForCurrentlyNonexistentWindow(
  99         base::Callback<gfx::NativeWindow(void)>());
 100   }
 101
 102  private:
 103   // ExtensionEnableFlowDelegate overrides.
 104   virtual void ExtensionEnableFlowFinished() OVERRIDE {
 105     callback_.Run();
 106     delete this;
 107   }
 108
 109   virtual void ExtensionEnableFlowAborted(bool user_initiated) OVERRIDE {
 110     callback_.Run();
 111     delete this;
 112   }
 113
 114   Profile* profile_;
 115   std::string extension_id_;
 116   base::Callback<void()> callback_;
 117   scoped_ptr<ExtensionEnableFlow> flow_;
 118
 119   DISALLOW_COPY_AND_ASSIGN(EnableViaPrompt);
 120 };
 121
 122 }  // namespace
 123
 124 namespace apps {
 125
 126 bool ExtensionAppShimHandler::Delegate::ProfileExistsForPath(
 127     const base::FilePath& path) {
 128   ProfileManager* profile_manager = g_browser_process->profile_manager();
 129   // Check for the profile name in the profile info cache to ensure that we
 130   // never access any directory that isn't a known profile.
 131   base::FilePath full_path = profile_manager->user_data_dir().Append(path);
 132   ProfileInfoCache& cache = profile_manager->GetProfileInfoCache();
 133   return cache.GetIndexOfProfileWithPath(full_path) != std::string::npos;
 134 }
 135
 136 Profile* ExtensionAppShimHandler::Delegate::ProfileForPath(
 137     const base::FilePath& path) {
 138   ProfileManager* profile_manager = g_browser_process->profile_manager();
 139   base::FilePath full_path = profile_manager->user_data_dir().Append(path);
 140   Profile* profile = profile_manager->GetProfileByPath(full_path);
 141
 142   // Use IsValidProfile to check if the profile has been created.
 143   return profile && profile_manager->IsValidProfile(profile) ? profile : NULL;
 144 }
 145
 146 void ExtensionAppShimHandler::Delegate::LoadProfileAsync(
 147     const base::FilePath& path,
 148     base::Callback<void(Profile*)> callback) {
 149   ProfileManager* profile_manager = g_browser_process->profile_manager();
 150   base::FilePath full_path = profile_manager->user_data_dir().Append(path);
 151   profile_manager->CreateProfileAsync(
 152       full_path,
 153       base::Bind(&ProfileLoadedCallback, callback),
 154       base::string16(), base::string16(), std::string());
 155 }
 156
 157 AppWindowList ExtensionAppShimHandler::Delegate::GetWindows(
 158     Profile* profile,
 159     const std::string& extension_id) {
 160   return AppWindowRegistry::Get(profile)->GetAppWindowsForApp(extension_id);
 161 }
 162
 163 const extensions::Extension*
 164 ExtensionAppShimHandler::Delegate::GetAppExtension(
 165     Profile* profile,
 166     const std::string& extension_id) {
 167   ExtensionRegistry* registry = ExtensionRegistry::Get(profile);
 168   const extensions::Extension* extension =
 169       registry->GetExtensionById(extension_id, ExtensionRegistry::ENABLED);
 170   return extension && extension->is_platform_app() ? extension : NULL;
 171 }
 172
 173 void ExtensionAppShimHandler::Delegate::EnableExtension(
 174     Profile* profile,
 175     const std::string& extension_id,
 176     const base::Callback<void()>& callback) {
 177   (new EnableViaPrompt(profile, extension_id, callback))->Run();
 178 }
 179
 180 void ExtensionAppShimHandler::Delegate::LaunchApp(
 181     Profile* profile,
 182     const extensions::Extension* extension,
 183     const std::vector<base::FilePath>& files) {
 184   CoreAppLauncherHandler::RecordAppLaunchType(
 185       extension_misc::APP_LAUNCH_CMD_LINE_APP, extension->GetType());
 186   if (files.empty()) {
 187     apps::LaunchPlatformApp(profile, extension);
 188   } else {
 189     for (std::vector<base::FilePath>::const_iterator it = files.begin();
 190          it != files.end(); ++it) {
 191       apps::LaunchPlatformAppWithPath(profile, extension, *it);
 192     }
 193   }
 194 }
 195
 196 void ExtensionAppShimHandler::Delegate::LaunchShim(
 197     Profile* profile,
 198     const extensions::Extension* extension) {
 199   web_app::MaybeLaunchShortcut(
 200       web_app::ShortcutInfoForExtensionAndProfile(extension, profile));
 201 }
 202
 203 void ExtensionAppShimHandler::Delegate::MaybeTerminate() {
 204   AppShimHandler::MaybeTerminate();
 205 }
 206
 207 ExtensionAppShimHandler::ExtensionAppShimHandler()
 208     : delegate_(new Delegate),
 209       weak_factory_(this) {
 210   // This is instantiated in BrowserProcessImpl::PreMainMessageLoopRun with
 211   // AppShimHostManager. Since PROFILE_CREATED is not fired until
 212   // ProfileManager::GetLastUsedProfile/GetLastOpenedProfiles, this should catch
 213   // notifications for all profiles.
 214   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
 215                  content::NotificationService::AllBrowserContextsAndSources());
 216   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
 217                  content::NotificationService::AllBrowserContextsAndSources());
 218 }
 219
 220 ExtensionAppShimHandler::~ExtensionAppShimHandler() {}
 221
 222 AppShimHandler::Host* ExtensionAppShimHandler::FindHost(
 223     Profile* profile,
 224     const std::string& app_id) {
 225   HostMap::iterator it = hosts_.find(make_pair(profile, app_id));
 226   return it == hosts_.end() ? NULL : it->second;
 227 }
 228
 229 // static
 230 void ExtensionAppShimHandler::QuitAppForWindow(AppWindow* app_window) {
 231   ExtensionAppShimHandler* handler = GetInstance();
 232   Host* host = handler->FindHost(
 233       Profile::FromBrowserContext(app_window->browser_context()),
 234       app_window->extension_id());
 235   if (host) {
 236     handler->OnShimQuit(host);
 237   } else {
 238     // App shims might be disabled or the shim is still starting up.
 239     AppWindowRegistry::Get(
 240         Profile::FromBrowserContext(app_window->browser_context()))
 241         ->CloseAllAppWindowsForApp(app_window->extension_id());
 242   }
 243 }
 244
 245 void ExtensionAppShimHandler::HideAppForWindow(AppWindow* app_window) {
 246   ExtensionAppShimHandler* handler = GetInstance();
 247   Profile* profile = Profile::FromBrowserContext(app_window->browser_context());
 248   Host* host = handler->FindHost(profile, app_window->extension_id());
 249   if (host)
 250     host->OnAppHide();
 251   else
 252     SetAppHidden(profile, app_window->extension_id(), true);
 253 }
 254
 255 void ExtensionAppShimHandler::FocusAppForWindow(AppWindow* app_window) {
 256   ExtensionAppShimHandler* handler = GetInstance();
 257   Profile* profile = Profile::FromBrowserContext(app_window->browser_context());
 258   const std::string& app_id = app_window->extension_id();
 259   Host* host = handler->FindHost(profile, app_id);
 260   if (host) {
 261     handler->OnShimFocus(host,
 262                          APP_SHIM_FOCUS_NORMAL,
 263                          std::vector<base::FilePath>());
 264   } else {
 265     FocusWindows(
 266         apps::AppWindowRegistry::Get(profile)->GetAppWindowsForApp(app_id));
 267   }
 268 }
 269
 270 // static
 271 bool ExtensionAppShimHandler::ActivateAndRequestUserAttentionForWindow(
 272     AppWindow* app_window) {
 273   ExtensionAppShimHandler* handler = GetInstance();
 274   Profile* profile = Profile::FromBrowserContext(app_window->browser_context());
 275   Host* host = handler->FindHost(profile, app_window->extension_id());
 276   if (host) {
 277     // Bring the window to the front without showing it.
 278     AppWindowRegistry::Get(profile)->AppWindowActivated(app_window);
 279     host->OnAppRequestUserAttention(APP_SHIM_ATTENTION_INFORMATIONAL);
 280     return true;
 281   } else {
 282     // Just show the app.
 283     SetAppHidden(profile, app_window->extension_id(), false);
 284     return false;
 285   }
 286 }
 287
 288 // static
 289 void ExtensionAppShimHandler::RequestUserAttentionForWindow(
 290     AppWindow* app_window,
 291     AppShimAttentionType attention_type) {
 292   ExtensionAppShimHandler* handler = GetInstance();
 293   Profile* profile = Profile::FromBrowserContext(app_window->browser_context());
 294   Host* host = handler->FindHost(profile, app_window->extension_id());
 295   if (host)
 296     host->OnAppRequestUserAttention(attention_type);
 297 }
 298
 299 // static
 300 void ExtensionAppShimHandler::OnChromeWillHide() {
 301   // Send OnAppHide to all the shims so that they go into the hidden state.
 302   // This is necessary so that when the shim is next focused, it will know to
 303   // unhide.
 304   ExtensionAppShimHandler* handler = GetInstance();
 305   for (HostMap::iterator it = handler->hosts_.begin();
 306        it != handler->hosts_.end();
 307        ++it) {
 308     it->second->OnAppHide();
 309   }
 310 }
 311
 312 void ExtensionAppShimHandler::OnShimLaunch(
 313     Host* host,
 314     AppShimLaunchType launch_type,
 315     const std::vector<base::FilePath>& files) {
 316   const std::string& app_id = host->GetAppId();
 317   DCHECK(crx_file::id_util::IdIsValid(app_id));
 318
 319   const base::FilePath& profile_path = host->GetProfilePath();
 320   DCHECK(!profile_path.empty());
 321
 322   if (!delegate_->ProfileExistsForPath(profile_path)) {
 323     // User may have deleted the profile this shim was originally created for.
 324     // TODO(jackhou): Add some UI for this case and remove the LOG.
 325     LOG(ERROR) << "Requested directory is not a known profile '"
 326                << profile_path.value() << "'.";
 327     host->OnAppLaunchComplete(APP_SHIM_LAUNCH_PROFILE_NOT_FOUND);
 328     return;
 329   }
 330
 331   Profile* profile = delegate_->ProfileForPath(profile_path);
 332
 333   if (profile) {
 334     OnProfileLoaded(host, launch_type, files, profile);
 335     return;
 336   }
 337
 338   // If the profile is not loaded, this must have been a launch by the shim.
 339   // Load the profile asynchronously, the host will be registered in
 340   // OnProfileLoaded.
 341   DCHECK_EQ(APP_SHIM_LAUNCH_NORMAL, launch_type);
 342   delegate_->LoadProfileAsync(
 343       profile_path,
 344       base::Bind(&ExtensionAppShimHandler::OnProfileLoaded,
 345                  weak_factory_.GetWeakPtr(),
 346                  host, launch_type, files));
 347
 348   // Return now. OnAppLaunchComplete will be called when the app is activated.
 349 }
 350
 351 // static
 352 ExtensionAppShimHandler* ExtensionAppShimHandler::GetInstance() {
 353   return g_browser_process->platform_part()
 354       ->app_shim_host_manager()
 355       ->extension_app_shim_handler();
 356 }
 357
 358 void ExtensionAppShimHandler::OnProfileLoaded(
 359     Host* host,
 360     AppShimLaunchType launch_type,
 361     const std::vector<base::FilePath>& files,
 362     Profile* profile) {
 363   const std::string& app_id = host->GetAppId();
 364
 365   // The first host to claim this (profile, app_id) becomes the main host.
 366   // For any others, focus or relaunch the app.
 367   if (!hosts_.insert(make_pair(make_pair(profile, app_id), host)).second) {
 368     OnShimFocus(host,
 369                 launch_type == APP_SHIM_LAUNCH_NORMAL ?
 370                     APP_SHIM_FOCUS_REOPEN : APP_SHIM_FOCUS_NORMAL,
 371                 files);
 372     host->OnAppLaunchComplete(APP_SHIM_LAUNCH_DUPLICATE_HOST);
 373     return;
 374   }
 375
 376   if (launch_type != APP_SHIM_LAUNCH_NORMAL) {
 377     host->OnAppLaunchComplete(APP_SHIM_LAUNCH_SUCCESS);
 378     return;
 379   }
 380
 381   // TODO(jeremya): Handle the case that launching the app fails. Probably we
 382   // need to watch for 'app successfully launched' or at least 'background page
 383   // exists/was created' and time out with failure if we don't see that sign of
 384   // life within a certain window.
 385   const extensions::Extension* extension =
 386       delegate_->GetAppExtension(profile, app_id);
 387   if (extension) {
 388     delegate_->LaunchApp(profile, extension, files);
 389     return;
 390   }
 391
 392   delegate_->EnableExtension(
 393       profile, app_id,
 394       base::Bind(&ExtensionAppShimHandler::OnExtensionEnabled,
 395                  weak_factory_.GetWeakPtr(),
 396                  host->GetProfilePath(), app_id, files));
 397 }
 398
 399 void ExtensionAppShimHandler::OnExtensionEnabled(
 400     const base::FilePath& profile_path,
 401     const std::string& app_id,
 402     const std::vector<base::FilePath>& files) {
 403   Profile* profile = delegate_->ProfileForPath(profile_path);
 404   if (!profile)
 405     return;
 406
 407   const extensions::Extension* extension =
 408       delegate_->GetAppExtension(profile, app_id);
 409   if (!extension || !delegate_->ProfileExistsForPath(profile_path)) {
 410     // If !extension, the extension doesn't exist, or was not re-enabled.
 411     // If the profile doesn't exist, it may have been deleted during the enable
 412     // prompt. In this case, NOTIFICATION_PROFILE_DESTROYED may not be fired
 413     // until later, so respond to the host now.
 414     Host* host = FindHost(profile, app_id);
 415     if (host)
 416       host->OnAppLaunchComplete(APP_SHIM_LAUNCH_APP_NOT_FOUND);
 417     return;
 418   }
 419
 420   delegate_->LaunchApp(profile, extension, files);
 421 }
 422
 423
 424 void ExtensionAppShimHandler::OnShimClose(Host* host) {
 425   // This might be called when shutting down. Don't try to look up the profile
 426   // since profile_manager might not be around.
 427   for (HostMap::iterator it = hosts_.begin(); it != hosts_.end(); ) {
 428     HostMap::iterator current = it++;
 429     if (current->second == host)
 430       hosts_.erase(current);
 431   }
 432 }
 433
 434 void ExtensionAppShimHandler::OnShimFocus(
 435     Host* host,
 436     AppShimFocusType focus_type,
 437     const std::vector<base::FilePath>& files) {
 438   DCHECK(delegate_->ProfileExistsForPath(host->GetProfilePath()));
 439   Profile* profile = delegate_->ProfileForPath(host->GetProfilePath());
 440
 441   const AppWindowList windows =
 442       delegate_->GetWindows(profile, host->GetAppId());
 443   bool windows_focused = FocusWindows(windows);
 444
 445   if (focus_type == APP_SHIM_FOCUS_NORMAL ||
 446       (focus_type == APP_SHIM_FOCUS_REOPEN && windows_focused)) {
 447     return;
 448   }
 449
 450   const extensions::Extension* extension =
 451       delegate_->GetAppExtension(profile, host->GetAppId());
 452   if (extension) {
 453     delegate_->LaunchApp(profile, extension, files);
 454   } else {
 455     // Extensions may have been uninstalled or disabled since the shim
 456     // started.
 457     host->OnAppClosed();
 458   }
 459 }
 460
 461 void ExtensionAppShimHandler::OnShimSetHidden(Host* host, bool hidden) {
 462   DCHECK(delegate_->ProfileExistsForPath(host->GetProfilePath()));
 463   Profile* profile = delegate_->ProfileForPath(host->GetProfilePath());
 464
 465   SetAppHidden(profile, host->GetAppId(), hidden);
 466 }
 467
 468 void ExtensionAppShimHandler::OnShimQuit(Host* host) {
 469   DCHECK(delegate_->ProfileExistsForPath(host->GetProfilePath()));
 470   Profile* profile = delegate_->ProfileForPath(host->GetProfilePath());
 471
 472   const std::string& app_id = host->GetAppId();
 473   const AppWindowList windows = delegate_->GetWindows(profile, app_id);
 474   for (AppWindowRegistry::const_iterator it = windows.begin();
 475        it != windows.end();
 476        ++it) {
 477     (*it)->GetBaseWindow()->Close();
 478   }
 479   // Once the last window closes, flow will end up in OnAppDeactivated via
 480   // AppLifetimeMonitor.
 481 }
 482
 483 void ExtensionAppShimHandler::set_delegate(Delegate* delegate) {
 484   delegate_.reset(delegate);
 485 }
 486
 487 void ExtensionAppShimHandler::Observe(
 488     int type,
 489     const content::NotificationSource& source,
 490     const content::NotificationDetails& details) {
 491   Profile* profile = content::Source<Profile>(source).ptr();
 492   if (profile->IsOffTheRecord())
 493     return;
 494
 495   switch (type) {
 496     case chrome::NOTIFICATION_PROFILE_CREATED: {
 497       AppLifetimeMonitorFactory::GetForProfile(profile)->AddObserver(this);
 498       break;
 499     }
 500     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
 501       AppLifetimeMonitorFactory::GetForProfile(profile)->RemoveObserver(this);
 502       // Shut down every shim associated with this profile.
 503       for (HostMap::iterator it = hosts_.begin(); it != hosts_.end(); ) {
 504         // Increment the iterator first as OnAppClosed may call back to
 505         // OnShimClose and invalidate the iterator.
 506         HostMap::iterator current = it++;
 507         if (profile->IsSameProfile(current->first.first)) {
 508           Host* host = current->second;
 509           host->OnAppClosed();
 510         }
 511       }
 512       break;
 513     }
 514     default: {
 515       NOTREACHED();  // Unexpected notification.
 516       break;
 517     }
 518   }
 519 }
 520
 521 void ExtensionAppShimHandler::OnAppStart(Profile* profile,
 522                                          const std::string& app_id) {}
 523
 524 void ExtensionAppShimHandler::OnAppActivated(Profile* profile,
 525                                              const std::string& app_id) {
 526   const extensions::Extension* extension =
 527       delegate_->GetAppExtension(profile, app_id);
 528   if (!extension)
 529     return;
 530
 531   Host* host = FindHost(profile, app_id);
 532   if (host) {
 533     host->OnAppLaunchComplete(APP_SHIM_LAUNCH_SUCCESS);
 534     OnShimFocus(host, APP_SHIM_FOCUS_NORMAL, std::vector<base::FilePath>());
 535     return;
 536   }
 537
 538   delegate_->LaunchShim(profile, extension);
 539 }
 540
 541 void ExtensionAppShimHandler::OnAppDeactivated(Profile* profile,
 542                                                const std::string& app_id) {
 543   Host* host = FindHost(profile, app_id);
 544   if (host)
 545     host->OnAppClosed();
 546
 547   if (hosts_.empty())
 548     delegate_->MaybeTerminate();
 549 }
 550
 551 void ExtensionAppShimHandler::OnAppStop(Profile* profile,
 552                                         const std::string& app_id) {}
 553
 554 void ExtensionAppShimHandler::OnChromeTerminating() {}
 555
 556 }  // namespace apps