Remove Profile usage from //apps

chrome/browser/apps/app_shim/extension_app_shim_handler_mac.h

 // 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.
 
 #ifndef CHROME_BROWSER_APPS_APP_SHIM_EXTENSION_APP_SHIM_HANDLER_MAC_H_
 #define CHROME_BROWSER_APPS_APP_SHIM_EXTENSION_APP_SHIM_HANDLER_MAC_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "apps/app_lifetime_monitor.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/apps/app_shim/app_shim_handler_mac.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 
 class Profile;
 
 namespace base {
 class FilePath;
 }
 
+namespace content {
+class BrowserContext;
+}
+
 namespace extensions {
 class AppWindow;
 class Extension;
 }
 
 namespace apps {
 
 // This app shim handler that handles events for app shims that correspond to an
 // extension.
 class ExtensionAppShimHandler : public AppShimHandler,
                                 public content::NotificationObserver,
                                 public AppLifetimeMonitor::Observer,
                                 public chrome::BrowserListObserver {
  public:
   class Delegate {
    public:
     virtual ~Delegate() {}
 
     virtual bool ProfileExistsForPath(const base::FilePath& path);
     virtual Profile* ProfileForPath(const base::FilePath& path);
     virtual void LoadProfileAsync(const base::FilePath& path,
                                   base::Callback<void(Profile*)> callback);
     virtual bool IsProfileLockedForPath(const base::FilePath& path);
 
     virtual extensions::AppWindowRegistry::AppWindowList GetWindows(
         Profile* profile,
         const std::string& extension_id);
 
     virtual const extensions::Extension* MaybeGetAppExtension(
-        Profile* profile,
+        content::BrowserContext* context,
         const std::string& extension_id);
     virtual void EnableExtension(Profile* profile,
                                  const std::string& extension_id,
                                  const base::Callback<void()>& callback);
     virtual void LaunchApp(Profile* profile,
                            const extensions::Extension* extension,
                            const std::vector<base::FilePath>& files);
     virtual void LaunchShim(Profile* profile,
                             const extensions::Extension* extension);
     virtual void LaunchUserManager();
 
     virtual void MaybeTerminate();
   };
 
   ExtensionAppShimHandler();
   ~ExtensionAppShimHandler() override;
 
   // Get the host corresponding to a profile and app id, or null if there is
   // none. Virtual for tests.
   virtual AppShimHandler::Host* FindHost(Profile* profile,
                                          const std::string& app_id);
 
   void SetHostedAppHidden(Profile* profile,
                           const std::string& app_id,
                           bool hidden);
 
   static const extensions::Extension* MaybeGetAppExtension(
-      Profile* profile,
+      content::BrowserContext* context,
       const std::string& extension_id);
 
   static const extensions::Extension* MaybeGetAppForBrowser(Browser* browser);
 
   static void QuitAppForWindow(extensions::AppWindow* app_window);
 
   static void QuitHostedAppForWindow(Profile* profile,
                                      const std::string& app_id);
 
   static void HideAppForWindow(extensions::AppWindow* app_window);
@@ skipping 20 matching lines @@
                     AppShimLaunchType launch_type,
                     const std::vector<base::FilePath>& files) override;
   void OnShimClose(Host* host) override;
   void OnShimFocus(Host* host,
                    AppShimFocusType focus_type,
                    const std::vector<base::FilePath>& files) override;
   void OnShimSetHidden(Host* host, bool hidden) override;
   void OnShimQuit(Host* host) override;
 
   // AppLifetimeMonitor::Observer overrides:
-  void OnAppStart(Profile* profile, const std::string& app_id) override;
-  void OnAppActivated(Profile* profile, const std::string& app_id) override;
-  void OnAppDeactivated(Profile* profile, const std::string& app_id) override;
-  void OnAppStop(Profile* profile, const std::string& app_id) override;
+  void OnAppStart(content::BrowserContext* context,
+                  const std::string& app_id) override;
+  void OnAppActivated(content::BrowserContext* context,
+                      const std::string& app_id) override;
+  void OnAppDeactivated(content::BrowserContext* context,
+                        const std::string& app_id) override;
+  void OnAppStop(content::BrowserContext* context,
+                 const std::string& app_id) override;
 
   // content::NotificationObserver overrides:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   // chrome::BrowserListObserver overrides;
   void OnBrowserAdded(Browser* browser) override;
   void OnBrowserRemoved(Browser* browser) override;
 
@@ skipping 46 matching lines @@
   content::NotificationRegistrar registrar_;
 
   base::WeakPtrFactory<ExtensionAppShimHandler> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionAppShimHandler);
 };
 
 }  // namespace apps
 
 #endif  // CHROME_BROWSER_APPS_APP_SHIM_EXTENSION_APP_SHIM_HANDLER_MAC_H_