Use ExtensionEnableFlow for shim initiated launches. (Mac)

apps/app_shim/extension_app_shim_handler_mac.cc

 // Copyright 2013 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 "apps/app_shim/extension_app_shim_handler_mac.h"
 
 #include "apps/app_lifetime_monitor_factory.h"
 #include "apps/app_shim/app_shim_host_manager_mac.h"
 #include "apps/app_shim/app_shim_messages.h"
 #include "apps/launcher.h"
 #include "apps/shell_window.h"
 #include "apps/shell_window_registry.h"
 #include "apps/ui/native_app_window.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/ui/extensions/extension_enable_flow.h"
+#include "chrome/browser/ui/extensions/extension_enable_flow_delegate.h"
 #include "chrome/browser/ui/web_applications/web_app_ui.h"
 #include "chrome/browser/ui/webui/ntp/core_app_launcher_handler.h"
 #include "chrome/browser/web_applications/web_app_mac.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "ui/base/cocoa/focus_window_set.h"
 
 namespace {
@@ skipping 33 matching lines @@
        it != windows.end(); ++it) {
     native_windows.insert((*it)->GetNativeWindow());
   }
   // Allow workspace switching. For the browser process, we can reasonably rely
   // on OS X to switch spaces for us and honor relevant user settings. But shims
   // don't have windows, so we have to do it ourselves.
   ui::FocusWindowSet(native_windows, true);
   return true;
 }
 
+// Attempts to launch a packaged app, prompting the user to enable it if
+// necessary. The prompt is shown in its own window.
+// This class manages its own lifetime.
+class EnableViaPrompt : public ExtensionEnableFlowDelegate {
+ public:
+  EnableViaPrompt(Profile* profile,
+                  const std::string& extension_id,
+                  const base::Callback<void()>& callback)
+      : profile_(profile),
+        extension_id_(extension_id),
+        callback_(callback) {
+  }
+
+  virtual ~EnableViaPrompt() {
+  }
+
+  void Run() {
+    flow_.reset(new ExtensionEnableFlow(profile_, extension_id_, this));
+    flow_->StartForCurrentlyNonexistentWindow(
+        base::Callback<gfx::NativeWindow(void)>());
+  }
+
+ private:
+  // ExtensionEnableFlowDelegate overrides.
+  virtual void ExtensionEnableFlowFinished() OVERRIDE {
+    callback_.Run();
+    delete this;
+  }
+
+  virtual void ExtensionEnableFlowAborted(bool user_initiated) OVERRIDE {
+    callback_.Run();
+    delete this;
+  }
+
+  Profile* profile_;
+  std::string extension_id_;
+  base::Callback<void()> callback_;
+  scoped_ptr<ExtensionEnableFlow> flow_;
+
+  DISALLOW_COPY_AND_ASSIGN(EnableViaPrompt);
+};
+
 }  // namespace
 
 namespace apps {
 
 bool ExtensionAppShimHandler::Delegate::ProfileExistsForPath(
     const base::FilePath& path) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   // Check for the profile name in the profile info cache to ensure that we
   // never access any directory that isn't a known profile.
   base::FilePath full_path = profile_manager->user_data_dir().Append(path);
@@ skipping 33 matching lines @@
     Profile* profile,
     const std::string& extension_id) {
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   DCHECK(extension_service);
   const extensions::Extension* extension =
       extension_service->GetExtensionById(extension_id, false);
   return extension && extension->is_platform_app() ? extension : NULL;
 }
 
+void ExtensionAppShimHandler::Delegate::EnableExtension(
+    Profile* profile,
+    const std::string& extension_id,
+    const base::Callback<void()>& callback) {
+  (new EnableViaPrompt(profile, extension_id, callback))->Run();
+}
+
 void ExtensionAppShimHandler::Delegate::LaunchApp(
     Profile* profile,
     const extensions::Extension* extension,
     const std::vector<base::FilePath>& files) {
   CoreAppLauncherHandler::RecordAppLaunchType(
       extension_misc::APP_LAUNCH_CMD_LINE_APP, extension->GetType());
   if (files.empty()) {
     apps::LaunchPlatformApp(profile, extension);
   } else {
     for (std::vector<base::FilePath>::const_iterator it = files.begin();
@@ skipping 140 matching lines @@
 
   // Return now. OnAppLaunchComplete will be called when the app is activated.
 }
 
 void ExtensionAppShimHandler::OnProfileLoaded(
     Host* host,
     AppShimLaunchType launch_type,
     const std::vector<base::FilePath>& files,
     Profile* profile) {
   const std::string& app_id = host->GetAppId();
-  // TODO(jackhou): Add some UI for this case and remove the LOG.
-  const extensions::Extension* extension =
-      delegate_->GetAppExtension(profile, app_id);
-  if (!extension) {
-    LOG(ERROR) << "Attempted to launch nonexistent app with id '"
-               << app_id << "'.";
-    host->OnAppLaunchComplete(APP_SHIM_LAUNCH_APP_NOT_FOUND);
-    return;
-  }
 
   // The first host to claim this (profile, app_id) becomes the main host.
   // For any others, focus or relaunch the app.
   if (!hosts_.insert(make_pair(make_pair(profile, app_id), host)).second) {
     OnShimFocus(host,
                 launch_type == APP_SHIM_LAUNCH_NORMAL ?
                     APP_SHIM_FOCUS_REOPEN : APP_SHIM_FOCUS_NORMAL,
                 files);
     host->OnAppLaunchComplete(APP_SHIM_LAUNCH_DUPLICATE_HOST);
     return;
   }
 
+  if (launch_type != APP_SHIM_LAUNCH_NORMAL) {
+    host->OnAppLaunchComplete(APP_SHIM_LAUNCH_SUCCESS);
+    return;
+  }
+
   // TODO(jeremya): Handle the case that launching the app fails. Probably we
   // need to watch for 'app successfully launched' or at least 'background page
   // exists/was created' and time out with failure if we don't see that sign of
   // life within a certain window.
-  if (launch_type == APP_SHIM_LAUNCH_NORMAL)
+  const extensions::Extension* extension =
+      delegate_->GetAppExtension(profile, app_id);
+  if (extension) {
     delegate_->LaunchApp(profile, extension, files);
-  else
-    host->OnAppLaunchComplete(APP_SHIM_LAUNCH_SUCCESS);
+    return;
+  }
+
+  delegate_->EnableExtension(
+      profile, app_id,
+      base::Bind(&ExtensionAppShimHandler::OnExtensionEnabled,
+                 weak_factory_.GetWeakPtr(),
+                 host->GetProfilePath(), app_id, files));
 }
 
+void ExtensionAppShimHandler::OnExtensionEnabled(
+    const base::FilePath& profile_path,
+    const std::string& app_id,
+    const std::vector<base::FilePath>& files) {
+  Profile* profile = delegate_->ProfileForPath(profile_path);
+  if (!profile)
+    return;
+
+  const extensions::Extension* extension =
+      delegate_->GetAppExtension(profile, app_id);
+  if (!extension || !delegate_->ProfileExistsForPath(profile_path)) {
+    // If !extension, the extension doesn't exist, or was not re-enabled.
+    // If the profile doesn't exist, it may have been deleted during the enable
+    // prompt. In this case, NOTIFICATION_PROFILE_DESTROYED may not be fired
+    // until later, so respond to the host now.
+    Host* host = FindHost(profile, app_id);
+    if (host)
+      host->OnAppLaunchComplete(APP_SHIM_LAUNCH_APP_NOT_FOUND);
+    return;
+  }
+
+  delegate_->LaunchApp(profile, extension, files);
+}
+
+
 void ExtensionAppShimHandler::OnShimClose(Host* host) {
   // This might be called when shutting down. Don't try to look up the profile
   // since profile_manager might not be around.
   for (HostMap::iterator it = hosts_.begin(); it != hosts_.end(); ) {
     HostMap::iterator current = it++;
     if (current->second == host)
       hosts_.erase(current);
   }
 }
 
@@ skipping 63 matching lines @@
       AppLifetimeMonitorFactory::GetForProfile(profile)->AddObserver(this);
       break;
     }
     case chrome::NOTIFICATION_PROFILE_DESTROYED: {
       AppLifetimeMonitorFactory::GetForProfile(profile)->RemoveObserver(this);
       // Shut down every shim associated with this profile.
       for (HostMap::iterator it = hosts_.begin(); it != hosts_.end(); ) {
         // Increment the iterator first as OnAppClosed may call back to
         // OnShimClose and invalidate the iterator.
         HostMap::iterator current = it++;
-        if (profile->IsSameProfile(current->first.first))
-          current->second->OnAppClosed();
+        if (profile->IsSameProfile(current->first.first)) {
+          Host* host = current->second;
+          host->OnAppClosed();
+        }
       }
       break;
     }
     default: {
       NOTREACHED();  // Unexpected notification.
       break;
     }
   }
 }
 
@@ skipping 26 matching lines @@
   if (hosts_.empty())
     delegate_->MaybeTerminate();
 }
 
 void ExtensionAppShimHandler::OnAppStop(Profile* profile,
                                         const std::string& app_id) {}
 
 void ExtensionAppShimHandler::OnChromeTerminating() {}
 
 }  // namespace apps