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