Home | History | Annotate | Download | only in app_shim 
      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 #ifndef APPS_APP_SHIM_EXTENSION_APP_SHIM_HANDLER_MAC_H_
      6 #define APPS_APP_SHIM_EXTENSION_APP_SHIM_HANDLER_MAC_H_
      7 
      8 #include <map>
      9 #include <string>
     10 #include <vector>
     11 
     12 #include "apps/app_lifetime_monitor.h"
     13 #include "apps/app_shim/app_shim_handler_mac.h"
     14 #include "apps/app_window_registry.h"
     15 #include "base/memory/scoped_ptr.h"
     16 #include "base/memory/weak_ptr.h"
     17 #include "content/public/browser/notification_observer.h"
     18 #include "content/public/browser/notification_registrar.h"
     19 
     20 class Profile;
     21 
     22 namespace base {
     23 class FilePath;
     24 }
     25 
     26 namespace content {
     27 class WebContents;
     28 }
     29 
     30 namespace extensions {
     31 class Extension;
     32 }
     33 
     34 namespace apps {
     35 
     36 class AppWindow;
     37 
     38 // This app shim handler that handles events for app shims that correspond to an
     39 // extension.
     40 class ExtensionAppShimHandler : public AppShimHandler,
     41                                 public content::NotificationObserver,
     42                                 public AppLifetimeMonitor::Observer {
     43  public:
     44   class Delegate {
     45    public:
     46     virtual ~Delegate() {}
     47 
     48     virtual bool ProfileExistsForPath(const base::FilePath& path);
     49     virtual Profile* ProfileForPath(const base::FilePath& path);
     50     virtual void LoadProfileAsync(const base::FilePath& path,
     51                                   base::Callback<void(Profile*)> callback);
     52 
     53     virtual AppWindowRegistry::AppWindowList GetWindows(
     54         Profile* profile,
     55         const std::string& extension_id);
     56 
     57     virtual const extensions::Extension* GetAppExtension(
     58         Profile* profile, const std::string& extension_id);
     59     virtual void EnableExtension(Profile* profile,
     60                                  const std::string& extension_id,
     61                                  const base::Callback<void()>& callback);
     62     virtual void LaunchApp(Profile* profile,
     63                            const extensions::Extension* extension,
     64                            const std::vector<base::FilePath>& files);
     65     virtual void LaunchShim(Profile* profile,
     66                             const extensions::Extension* extension);
     67 
     68     virtual void MaybeTerminate();
     69   };
     70 
     71   ExtensionAppShimHandler();
     72   virtual ~ExtensionAppShimHandler();
     73 
     74   AppShimHandler::Host* FindHost(Profile* profile, const std::string& app_id);
     75 
     76   static void QuitAppForWindow(AppWindow* app_window);
     77 
     78   static void HideAppForWindow(AppWindow* app_window);
     79 
     80   static void FocusAppForWindow(AppWindow* app_window);
     81 
     82   // Brings the window to the front without showing it and instructs the shim to
     83   // request user attention. Returns false if there is no shim for this window.
     84   static bool RequestUserAttentionForWindow(AppWindow* app_window);
     85 
     86   // AppShimHandler overrides:
     87   virtual void OnShimLaunch(Host* host,
     88                             AppShimLaunchType launch_type,
     89                             const std::vector<base::FilePath>& files) OVERRIDE;
     90   virtual void OnShimClose(Host* host) OVERRIDE;
     91   virtual void OnShimFocus(Host* host,
     92                            AppShimFocusType focus_type,
     93                            const std::vector<base::FilePath>& files) OVERRIDE;
     94   virtual void OnShimSetHidden(Host* host, bool hidden) OVERRIDE;
     95   virtual void OnShimQuit(Host* host) OVERRIDE;
     96 
     97   // AppLifetimeMonitor::Observer overrides:
     98   virtual void OnAppStart(Profile* profile, const std::string& app_id) OVERRIDE;
     99   virtual void OnAppActivated(Profile* profile,
    100                               const std::string& app_id) OVERRIDE;
    101   virtual void OnAppDeactivated(Profile* profile,
    102                                 const std::string& app_id) OVERRIDE;
    103   virtual void OnAppStop(Profile* profile, const std::string& app_id) OVERRIDE;
    104   virtual void OnChromeTerminating() OVERRIDE;
    105 
    106   // content::NotificationObserver overrides:
    107   virtual void Observe(int type,
    108                        const content::NotificationSource& source,
    109                        const content::NotificationDetails& details) OVERRIDE;
    110 
    111  protected:
    112   typedef std::map<std::pair<Profile*, std::string>, AppShimHandler::Host*>
    113       HostMap;
    114 
    115   // Exposed for testing.
    116   void set_delegate(Delegate* delegate);
    117   HostMap& hosts() { return hosts_; }
    118   content::NotificationRegistrar& registrar() { return registrar_; }
    119 
    120  private:
    121   // This is passed to Delegate::LoadProfileAsync for shim-initiated launches
    122   // where the profile was not yet loaded.
    123   void OnProfileLoaded(Host* host,
    124                        AppShimLaunchType launch_type,
    125                        const std::vector<base::FilePath>& files,
    126                        Profile* profile);
    127 
    128   // This is passed to Delegate::EnableViaPrompt for shim-initiated launches
    129   // where the extension is disabled.
    130   void OnExtensionEnabled(const base::FilePath& profile_path,
    131                           const std::string& app_id,
    132                           const std::vector<base::FilePath>& files);
    133 
    134   scoped_ptr<Delegate> delegate_;
    135 
    136   HostMap hosts_;
    137 
    138   content::NotificationRegistrar registrar_;
    139 
    140   base::WeakPtrFactory<ExtensionAppShimHandler> weak_factory_;
    141 
    142   DISALLOW_COPY_AND_ASSIGN(ExtensionAppShimHandler);
    143 };
    144 
    145 }  // namespace apps
    146 
    147 #endif  // APPS_APP_SHIM_EXTENSION_APP_SHIM_HANDLER_MAC_H_
    148