Refactor ShellWindow to separate platform-specific code.

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 "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/file_select_helper.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/intents/web_intents_util.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/extensions/native_shell_window.h"
 #include "chrome/browser/ui/intents/web_intent_picker_controller.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
@@ skipping 33 matching lines @@
 ShellWindow::CreateParams::CreateParams()
   : frame(ShellWindow::CreateParams::FRAME_CHROME),
     bounds(10, 10, kDefaultWidth, kDefaultHeight) {
 }
 
 ShellWindow* ShellWindow::Create(Profile* profile,
                                  const extensions::Extension* extension,
                                  const GURL& url,
                                  const ShellWindow::CreateParams& params) {
   // This object will delete itself when the window is closed.
-  ShellWindow* window =
-      ShellWindow::CreateImpl(profile, extension, url, params);
+  ShellWindow* window = new ShellWindow(profile, extension);
+  window->Init(url, params);
   ShellWindowRegistry::Get(profile)->AddShellWindow(window);
   return window;
 }
 
 ShellWindow::ShellWindow(Profile* profile,
-                         const extensions::Extension* extension,
-                         const GURL& url)
+                         const extensions::Extension* extension)
     : profile_(profile),
       extension_(extension),
+      web_contents_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           extension_function_dispatcher_(profile, this)) {
-  // TODO(jeremya) this should all be done in an Init() method, not in the
-  // constructor. During this code, WebContents will be calling
-  // WebContentsDelegate methods, but at this point the vftables for the
-  // subclass are not yet in place, since it's still halfway through its
-  // constructor. As a result, overridden virtual methods won't be called.
+}
+
+void ShellWindow::Init(const GURL& url,
+                       const ShellWindow::CreateParams& params) {
   web_contents_ = WebContents::Create(
-      profile, SiteInstance::CreateForURL(profile, url), MSG_ROUTING_NONE, NULL,
-      NULL);
+      profile(), SiteInstance::CreateForURL(profile(), url),
+      MSG_ROUTING_NONE, NULL, NULL);
   contents_.reset(new TabContents(web_contents_));
   content::WebContentsObserver::Observe(web_contents_);
   web_contents_->SetDelegate(this);
   chrome::SetViewType(web_contents_, chrome::VIEW_TYPE_APP_SHELL);
   web_contents_->GetMutableRendererPrefs()->
       browser_handles_all_top_level_requests = true;
   web_contents_->GetRenderViewHost()->SyncRendererPrefs();
 
+  native_window_ = NativeShellWindow::Create(this, params);
+
   // Block the created RVH from loading anything until the background page
   // has had a chance to do any initialization it wants.
   SuspendRenderViewHost(web_contents_->GetRenderViewHost());
 
   // TODO(jeremya): there's a bug where navigating a web contents to an
   // extension URL causes it to create a new RVH and discard the old (perfectly
   // usable) one. To work around this, we watch for a RVH_CHANGED message from
   // the web contents (which will be sent during LoadURL) and suspend resource
   // requests on the new RVH to ensure that we block the new RVH from loading
   // anything. It should be okay to remove the NOTIFICATION_RVH_CHANGED
@@ skipping 23 matching lines @@
   browser::StartKeepAlive();
 }
 
 ShellWindow::~ShellWindow() {
   // Unregister now to prevent getting NOTIFICATION_APP_TERMINATING if we're the
   // last window open.
   registrar_.RemoveAll();
 
   // Remove shutdown prevention.
   browser::EndKeepAlive();
-}
 
-bool ShellWindow::IsFullscreenOrPending() const {
-  return false;
+  delete native_window_;
 }
 
 void ShellWindow::RequestMediaAccessPermission(
     content::WebContents* web_contents,
     const content::MediaStreamRequest* request,
     const content::MediaResponseCallback& callback) {
   content::MediaStreamDevices devices;
 
   content::MediaStreamDeviceMap::const_iterator iter =
       request->devices.find(content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE);
@@ skipping 73 matching lines @@
       disposition == NEW_BACKGROUND_TAB ? disposition : NEW_FOREGROUND_TAB;
   chrome::AddWebContents(browser, NULL, new_contents, disposition, initial_pos,
                          user_gesture);
 }
 
 void ShellWindow::OnNativeClose() {
   ShellWindowRegistry::Get(profile_)->RemoveShellWindow(this);
   delete this;
 }
 
+BaseWindow* ShellWindow::GetBaseWindow() {
+  return native_window_;
+}
+
 string16 ShellWindow::GetTitle() const {
   // WebContents::GetTitle() will return the page's URL if there's no <title>
   // specified. However, we'd prefer to show the name of the extension in that
   // case, so we directly inspect the NavigationEntry's title.
   if (!web_contents()->GetController().GetActiveEntry() ||
       web_contents()->GetController().GetActiveEntry()->GetTitle().empty())
     return UTF8ToUTF16(extension()->name());
   return web_contents()->GetTitle();
 }
 
 bool ShellWindow::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ShellWindow, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_UpdateDraggableRegions,
                         UpdateDraggableRegions)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+void ShellWindow::UpdateDraggableRegions(
+    const std::vector<extensions::DraggableRegion>& regions) {
+  native_window_->UpdateDraggableRegions(regions);
+}
+
 void ShellWindow::CloseContents(WebContents* contents) {
-  Close();
+  DCHECK(contents == web_contents_);
+  native_window_->Close();
 }
 
 bool ShellWindow::ShouldSuppressDialogs() {
   return true;
 }
 
 void ShellWindow::WebIntentDispatch(
     content::WebContents* web_contents,
     content::WebIntentsDispatcher* intents_dispatcher) {
   if (!web_intents::IsWebIntentsEnabledForProfile(profile_))
@@ skipping 11 matching lines @@
   FileSelectHelper::RunFileChooser(tab, params);
 }
 
 bool ShellWindow::IsPopupOrPanel(const WebContents* source) const {
   DCHECK(source == web_contents_);
   return true;
 }
 
 void ShellWindow::MoveContents(WebContents* source, const gfx::Rect& pos) {
   DCHECK(source == web_contents_);
-  SetBounds(pos);
+  native_window_->SetBounds(pos);
 }
 
 void ShellWindow::NavigationStateChanged(
     const content::WebContents* source, unsigned changed_flags) {
   DCHECK(source == web_contents_);
   if (changed_flags & content::INVALIDATE_TYPE_TITLE)
-    UpdateWindowTitle();
+    native_window_->UpdateWindowTitle();
 }
 
 void ShellWindow::ToggleFullscreenModeForTab(content::WebContents* source,
                                              bool enter_fullscreen) {
   DCHECK(source == web_contents_);
-  SetFullscreen(enter_fullscreen);
+  native_window_->SetFullscreen(enter_fullscreen);
 }
 
 bool ShellWindow::IsFullscreenForTabOrPending(
     const content::WebContents* source) const {
   DCHECK(source == web_contents_);
-  return IsFullscreenOrPending();
+  return native_window_->IsFullscreenOrPending();
 }
 
 void ShellWindow::Observe(int type,
                           const content::NotificationSource& source,
                           const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED: {
       // TODO(jeremya): once http://crbug.com/123007 is fixed, we'll no longer
       // need to suspend resource requests here (the call in the constructor
       // should be enough).
       content::Details<std::pair<RenderViewHost*, RenderViewHost*> >
           host_details(details);
       if (host_details->first)
         SuspendRenderViewHost(host_details->second);
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const extensions::Extension* unloaded_extension =
           content::Details<extensions::UnloadedExtensionInfo>(
               details)->extension;
       if (extension_ == unloaded_extension)
-        Close();
+        native_window_->Close();
       break;
     }
     case content::NOTIFICATION_APP_TERMINATING:
-      Close();
+      native_window_->Close();
       break;
     default:
       NOTREACHED() << "Received unexpected notification";
   }
 }
 
 extensions::WindowController*
 ShellWindow::GetExtensionWindowController() const {
   return NULL;
 }
 
 void ShellWindow::OnRequest(const ExtensionHostMsg_Request_Params& params) {
   extension_function_dispatcher_.Dispatch(params,
                                           web_contents_->GetRenderViewHost());
 }
 
 void ShellWindow::AddMessageToDevToolsConsole(ConsoleMessageLevel level,
                                               const std::string& message) {
   content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
   rvh->Send(new ExtensionMsg_AddMessageToConsole(
       rvh->GetRoutingID(), level, message));
 }