Pull shell window stuff out of ExtensionHost and put in ShellWindow

This will let us iterate quicker on ShellWindow and platform apps and let them do things (like have TabContentsWrappers) that normal ExtensionHost windows shouldn't do.

BUG=None
TEST=Platform apps still work, browser tests.

Review URL: https://chromiumcodereview.appspot.com/10119003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@136239 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 136 insertions, 66 deletions

diff --git a/chrome/browser/ui/extensions/shell_window.cc b/chrome/browser/ui/extensions/shell_window.cc
index f624f95..0371ab7 100644
--- a/chrome/browser/ui/extensions/shell_window.cc
+++ b/chrome/browser/ui/extensions/shell_window.cc
@@ -8,14 +8,24 @@
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
 #include "chrome/browser/extensions/extension_window_controller.h"
+#include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/chrome_view_type.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/site_instance.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/renderer_preferences.h"
+
+using content::SiteInstance;
+using content::WebContents;
 
 namespace internal {
 
@@ -26,7 +36,6 @@ class ShellWindowController : public ExtensionWindowController {
   // Overriden from ExtensionWindowController
   virtual int GetWindowId() const OVERRIDE;
   virtual std::string GetWindowTypeText() const OVERRIDE;
-  virtual base::DictionaryValue* CreateWindowValue() const OVERRIDE;
   virtual base::DictionaryValue* CreateWindowValueWithTabs() const OVERRIDE;
   virtual bool CanClose(Reason* reason) const OVERRIDE;
   virtual void SetFullscreenMode(bool is_fullscreen,
@@ -49,15 +58,8 @@ int ShellWindowController::GetWindowId() const {
   return static_cast<int>(shell_window_->session_id().id());
 }
 
-namespace keys = extension_tabs_module_constants;
-
 std::string ShellWindowController::GetWindowTypeText() const {
-  return keys::kWindowTypeValueShell;
-}
-
-base::DictionaryValue* ShellWindowController::CreateWindowValue() const {
-  DictionaryValue* result = ExtensionWindowController::CreateWindowValue();
-  return result;
+  return extension_tabs_module_constants::kWindowTypeValueShell;
 }
 
 base::DictionaryValue* ShellWindowController::CreateWindowValueWithTabs()
@@ -79,48 +81,32 @@ void ShellWindowController::SetFullscreenMode(bool is_fullscreen,
 ShellWindow* ShellWindow::Create(Profile* profile,
                                  const Extension* extension,
                                  const GURL& url) {
-  ExtensionProcessManager* manager = profile->GetExtensionProcessManager();
-  DCHECK(manager);
-
   // This object will delete itself when the window is closed.
-  return ShellWindow::CreateShellWindow(
-      manager->CreateShellHost(extension, url));
-}
-
-void ShellWindow::Observe(int type,
-                          const content::NotificationSource& source,
-                          const content::NotificationDetails& details) {
-  switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE:
-      if (content::Details<ExtensionHost>(host_.get()) == details)
-        Close();
-      break;
-    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
-      const Extension* unloaded_extension =
-          content::Details<UnloadedExtensionInfo>(details)->extension;
-      // We compare extension IDs and not Extension pointers since ExtensionHost
-      // nulls out its Extension pointer when it gets this notification.
-      if (host_->extension_id() == unloaded_extension->id())
-        Close();
-      break;
-    }
-    case content::NOTIFICATION_APP_TERMINATING:
-      Close();
-      break;
-    default:
-      NOTREACHED() << "Received unexpected notification";
-  }
+  return ShellWindow::CreateImpl(profile, extension, url);
 }
 
-ShellWindow::ShellWindow(ExtensionHost* host)
-    : host_(host) {
-  // Close the window in response to window.close() and the like.
-  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_VIEW_SHOULD_CLOSE,
-                 content::Source<Profile>(host->profile()));
-  // Also close if the window if the extension has been unloaded (parallels
-  // NOTIFICATION_EXTENSION_UNLOADED closing the app's tabs in TabStripModel).
+ShellWindow::ShellWindow(Profile* profile,
+                         const Extension* extension,
+                         const GURL& url)
+    : profile_(profile),
+      extension_(extension),
+      ALLOW_THIS_IN_INITIALIZER_LIST(
+          extension_function_dispatcher_(profile, this)) {
+  web_contents_.reset(WebContents::Create(
+      profile, SiteInstance::CreateForURL(profile, url), MSG_ROUTING_NONE, NULL,
+      NULL));
+  content::WebContentsObserver::Observe(web_contents_.get());
+  web_contents_->SetDelegate(this);
+  web_contents_->SetViewType(chrome::VIEW_TYPE_APP_SHELL);
+  web_contents_->GetMutableRendererPrefs()->browser_handles_all_requests =
+      true;
+  web_contents_->GetRenderViewHost()->SyncRendererPrefs();
+
+  web_contents_->GetController().LoadURL(
+      url, content::Referrer(), content::PAGE_TRANSITION_LINK,
+      std::string());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
-                 content::Source<Profile>(host->profile()));
+                 content::Source<Profile>(profile_));
   // Close when the browser is exiting.
   // TODO(mihaip): we probably don't want this in the long run (when platform
   // apps are no longer tied to the browser process).
@@ -132,7 +118,9 @@ ShellWindow::ShellWindow(ExtensionHost* host)
 
   // Make this window available to the extension API.
   extension_window_controller_.reset(
-      new internal::ShellWindowController(this, host->profile()));
+      new internal::ShellWindowController(this, profile_));
+
+  ShellWindowRegistry::Get(profile_)->AddShellWindow(this);
 }
 
 ShellWindow::~ShellWindow() {
@@ -140,6 +128,56 @@ ShellWindow::~ShellWindow() {
   // last window open.
   registrar_.RemoveAll();
 
+  ShellWindowRegistry::Get(profile_)->RemoveShellWindow(this);
+
   // Remove shutdown prevention.
   BrowserList::EndKeepAlive();
 }
+
+bool ShellWindow::OnMessageReceived(const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(ShellWindow, message)
+    IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void ShellWindow::CloseContents(WebContents* contents) {
+  Close();
+}
+
+// TODO(benwells): Rearrange so users of this can call
+// WebContents::set_should_suppress_dialogs(bool) instead of overriding
+// this delegate function.
+bool ShellWindow::ShouldSuppressDialogs() {
+  return true;
+}
+
+void ShellWindow::Observe(int type,
+                          const content::NotificationSource& source,
+                          const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
+      const Extension* unloaded_extension =
+          content::Details<UnloadedExtensionInfo>(details)->extension;
+      if (extension_ == unloaded_extension)
+        Close();
+      break;
+    }
+    case content::NOTIFICATION_APP_TERMINATING:
+      Close();
+      break;
+    default:
+      NOTREACHED() << "Received unexpected notification";
+  }
+}
+
+ExtensionWindowController* ShellWindow::GetExtensionWindowController() const {
+  return extension_window_controller_.get();
+}
+
+void ShellWindow::OnRequest(const ExtensionHostMsg_Request_Params& params) {
+  extension_function_dispatcher_.Dispatch(params,
+                                          web_contents_->GetRenderViewHost());
+}
diff --git a/chrome/browser/ui/extensions/shell_window.h b/chrome/browser/ui/extensions/shell_window.h
index 2790b74..dec4dd8 100644
--- a/chrome/browser/ui/extensions/shell_window.h
+++ b/chrome/browser/ui/extensions/shell_window.h
@@ -7,14 +7,15 @@
 #pragma once
 
 #include "base/memory/scoped_ptr.h"
+#include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/sessions/session_id.h"
-#include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/ui/base_window.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/web_contents_delegate.h"
+#include "content/public/browser/web_contents_observer.h"
 
 class Extension;
-class ExtensionHost;
 class ExtensionWindowController;
 class GURL;
 class Profile;
@@ -23,43 +24,74 @@ namespace content {
 class WebContents;
 }
 
+// ShellWindow is the type of window used by platform apps. Shell windows
+// have a WebContents but none of the chrome of normal browser windows.
 class ShellWindow : public content::NotificationObserver,
+                    public content::WebContentsDelegate,
+                    public content::WebContentsObserver,
+                    public ExtensionFunctionDispatcher::Delegate,
                     public BaseWindow {
  public:
-  // TODO(mihaip): Switch from hardcoded defaults to passing in the window
-  // creation parameters to ShellWindow::Create.
-  static const int kDefaultWidth = 512;
-  static const int kDefaultHeight = 384;
+  static ShellWindow* Create(Profile* profile,
+                             const Extension* extension,
+                             const GURL& url);
 
-  content::WebContents* web_contents() const { return host_->host_contents(); }
   const SessionID& session_id() const { return session_id_; }
   const ExtensionWindowController* extension_window_controller() const {
     return extension_window_controller_.get();
   }
 
-  static ShellWindow* Create(Profile* profile,
-                             const Extension* extension,
-                             const GURL& url);
+ protected:
+  // TODO(mihaip): Switch from hardcoded defaults to passing in the window
+  // creation parameters to ShellWindow::Create.
+  static const int kDefaultWidth = 512;
+  static const int kDefaultHeight = 384;
+
+  ShellWindow(Profile* profile,
+              const Extension* extension,
+              const GURL& url);
+  virtual ~ShellWindow();
+
+  const Extension* extension() const { return extension_; }
+  content::WebContents* web_contents() const { return web_contents_.get(); }
+
+ private:
+  // PlatformAppBrowserTest needs access to web_contents()
+  friend class PlatformAppBrowserTest;
+
+  // Instantiates a platform-specific ShellWindow subclass (one implementation
+  // per platform). Public users of ShellWindow should use ShellWindow::Create.
+  static ShellWindow* CreateImpl(Profile* profile,
+                                 const Extension* extension,
+                                 const GURL& url);
+
+  // content::WebContentsObserver
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+  // content::WebContentsDelegate
+  virtual void CloseContents(content::WebContents* contents) OVERRIDE;
+  virtual bool ShouldSuppressDialogs() OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
- protected:
-  explicit ShellWindow(ExtensionHost* host_);
-  virtual ~ShellWindow();
+  virtual ExtensionWindowController* GetExtensionWindowController() const
+      OVERRIDE;
 
-  // Instantiates a platform-specific ShellWindow subclass (one implementation
-  // per platform). Public users of ShellWindow should use ShellWindow::Create.
-  static ShellWindow* CreateShellWindow(ExtensionHost* host);
+  // Message handlers.
+  void OnRequest(const ExtensionHostMsg_Request_Params& params);
+
+  Profile* profile_;  // weak pointer - owned by ProfileManager.
+  const Extension* extension_;  // weak pointer - owned by ExtensionService.
 
   const SessionID session_id_;
-  scoped_ptr<ExtensionHost> host_;
+  scoped_ptr<content::WebContents> web_contents_;
   content::NotificationRegistrar registrar_;
   scoped_ptr<ExtensionWindowController> extension_window_controller_;
+  ExtensionFunctionDispatcher extension_function_dispatcher_;
 
- private:
   DISALLOW_COPY_AND_ASSIGN(ShellWindow);
 };