Allow Chrome apps to create Ash Panels (apps v2)

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/extension_system.h"
 #include "chrome/browser/extensions/shell_window_geometry_cache.h"
@@ skipping 32 matching lines @@
 #include "content/public/browser/resource_dispatcher_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_intents_dispatcher.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/public/common/renderer_preferences.h"
 #include "third_party/skia/include/core/SkRegion.h"
 
 namespace app_window = extensions::api::app_window;
 
+#if defined(USE_ASH)
+#include "chrome/browser/ui/ash/shell_panel_ash.h"
+#endif
+
 using content::BrowserThread;
 using content::ConsoleMessageLevel;
 using content::RenderViewHost;
 using content::ResourceDispatcherHost;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::APIPermission;
 using extensions::RequestMediaAccessPermissionHelper;
 
 namespace {
 const int kDefaultWidth = 512;
 const int kDefaultHeight = 384;
 
 void SuspendRenderViewHost(RenderViewHost* rvh) {
   DCHECK(rvh);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourceDispatcherHost::BlockRequestsForRoute,
           base::Unretained(ResourceDispatcherHost::Get()),
           rvh->GetProcess()->GetID(), rvh->GetRoutingID()));
 }
 
 }  // namespace
 
 ShellWindow::CreateParams::CreateParams()
-  : frame(ShellWindow::CreateParams::FRAME_CHROME),
+  : window_type(ShellWindow::WINDOW_TYPE_DEFAULT),
+    frame(ShellWindow::CreateParams::FRAME_CHROME),
     bounds(INT_MIN, INT_MIN, INT_MIN, INT_MIN),
     restore_position(true), restore_size(true),
     creator_process_id(0), hidden(false) {
 }
 
 ShellWindow::CreateParams::~CreateParams() {
 }
 
 ShellWindow* ShellWindow::Create(Profile* profile,
                                  const extensions::Extension* extension,
                                  const GURL& url,
-                                 const ShellWindow::CreateParams& params) {
+                                 const CreateParams& params) {
   // This object will delete itself when the window is closed.
-  ShellWindow* window = new ShellWindow(profile, extension);
+  ShellWindow* window = new ShellWindow(params.window_type, profile, extension);
   window->Init(url, params);
   extensions::ShellWindowRegistry::Get(profile)->AddShellWindow(window);
   return window;
 }
 
-ShellWindow::ShellWindow(Profile* profile,
+ShellWindow::ShellWindow(WindowType window_type,
+                         Profile* profile,
                          const extensions::Extension* extension)
     : profile_(profile),
       extension_(extension),
       web_contents_(NULL),
+      window_type_(window_type),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           extension_function_dispatcher_(profile, this)) {
 }
 
 void ShellWindow::Init(const GURL& url,
                        const ShellWindow::CreateParams& params) {
   web_contents_.reset(WebContents::Create(
       profile(), SiteInstance::CreateForURL(profile(), url), MSG_ROUTING_NONE,
       NULL));
   ConstrainedWindowTabHelper::CreateForWebContents(web_contents_.get());
@@ skipping 32 matching lines @@
           bounds.set_origin(cached_bounds.origin());
         if (params.restore_size)
           bounds.set_size(cached_bounds.size());
       }
     }
   }
 
   ShellWindow::CreateParams new_params = params;
   new_params.bounds = bounds;
 
-  native_window_.reset(NativeShellWindow::Create(this, new_params));
+  DCHECK(!native_window_.get());
+#if defined(USE_ASH)
+  if (params.window_type == WINDOW_TYPE_PANEL)
+    native_window_.reset(new ShellPanelAsh(this, params));
+#endif
+  if (!native_window_.get())
+    native_window_.reset(NativeShellWindow::Create(this, new_params));
+
   SaveWindowPosition();
 
-  if (!params.hidden)
-    GetBaseWindow()->Show();
+  if (!params.hidden) {
+    if (params.window_type != WINDOW_TYPE_PANEL)

[jeremya, 2012/11/15 01:09:25]

Shouldn't this be == then?

[stevenjb, 2012/11/16 23:42:40]

Yes. Done.

+      GetBaseWindow()->ShowInactive();  // Panels are not activated by default.
+    else
+      GetBaseWindow()->Show();
+  }
 
   // If the new view is in the same process as the creator, block the created
   // RVH from loading anything until the background page has had a chance to do
   // any initialization it wants. If it's a different process, the new RVH
   // shouldn't communicate with the background page anyway (e.g. sandboxed).
   if (web_contents_->GetRenderViewHost()->GetProcess()->GetID() ==
       params.creator_process_id) {
     SuspendRenderViewHost(web_contents_->GetRenderViewHost());
   } else {
     VLOG(1) << "ShellWindow created in new process ("
@@ skipping 128 matching lines @@
 }
 
 BaseWindow* ShellWindow::GetBaseWindow() {
   return native_window_.get();
 }
 
 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() ||
+  if (!web_contents() ||
+      !web_contents()->GetController().GetActiveEntry() ||
       web_contents()->GetController().GetActiveEntry()->GetTitle().empty())
     return UTF8ToUTF16(extension()->name());
   string16 title = web_contents()->GetTitle();
   Browser::FormatTitleForDisplay(&title);
   return title;
 }
 
 bool ShellWindow::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ShellWindow, message)
@@ skipping 196 matching lines @@
     const extensions::DraggableRegion& region = *iter;
     sk_region->op(
         region.bounds.x(),
         region.bounds.y(),
         region.bounds.right(),
         region.bounds.bottom(),
         region.draggable ? SkRegion::kUnion_Op : SkRegion::kDifference_Op);
   }
   return sk_region;
 }