Pull shell window stuff out of ExtensionHost and put in ShellWindow

chrome/browser/ui/extensions/shell_window.cc

 // Copyright (c) 2012 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 "chrome/browser/ui/extensions/shell_window.h"
 
 #include "chrome/browser/ui/browser_list.h"
 #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/platform_app_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 {
 
 class ShellWindowController : public ExtensionWindowController {
  public:
   ShellWindowController(ShellWindow* shell_window, Profile* profile);
 
   // Overriden from ExtensionWindowController
   virtual int GetWindowId() const OVERRIDE;
   virtual std::string GetWindowTypeText() const OVERRIDE;
@@ skipping 47 matching lines @@
 
 }  // namespace internal
 
 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));
+  return ShellWindow::CreateShellWindow(profile, extension, url);
+}
+
+WebContents* ShellWindow::GetAssociatedWebContents() const {
+  return NULL;
+}
+
+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();
+}
+
+bool ShellWindow::ShouldSuppressDialogs() {
+  return true;
 }
 
 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())
+      if (extension_ == unloaded_extension)
         Close();
       break;
     }
     case content::NOTIFICATION_APP_TERMINATING:
       Close();
       break;
     default:
       NOTREACHED() << "Received unexpected notification";
   }
 }
 
-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).
   registrar_.Add(this, content::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
 
   // Prevent the browser process from shutting down while this window is open.
   BrowserList::StartKeepAlive();
 
   // Make this window available to the extension API.
   extension_window_controller_.reset(
-      new internal::ShellWindowController(this, host->profile()));
+      new internal::ShellWindowController(this, profile_));
+
+  PlatformAppRegistry::Get(profile_)->AddShellWindow(this);
 }
 
 ShellWindow::~ShellWindow() {
   // Unregister now to prevent getting NOTIFICATION_APP_TERMINATING if we're the
   // last window open.
   registrar_.RemoveAll();
 
+  PlatformAppRegistry::Get(profile_)->RemoveShellWindow(this);
+
   // Remove shutdown prevention.
   BrowserList::EndKeepAlive();
 }
+
+Browser* ShellWindow::GetBrowser() {
+  return NULL;
+}
+
+void ShellWindow::OnRequest(const ExtensionHostMsg_Request_Params& params) {
+  extension_function_dispatcher_.Dispatch(params,
+                                          web_contents_->GetRenderViewHost());
+}