src/apps/app_window_contents.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "apps/app_window_contents.h"
   6
   7 #include "apps/ui/native_app_window.h"
   8 #include "chrome/browser/chrome_notification_types.h"
   9 #include "chrome/browser/profiles/profile.h"
  10 #include "chrome/common/extensions/api/app_window.h"
  11 #include "chrome/common/extensions/extension_messages.h"
  12 #include "content/public/browser/browser_thread.h"
  13 #include "content/public/browser/render_process_host.h"
  14 #include "content/public/browser/render_view_host.h"
  15 #include "content/public/browser/resource_dispatcher_host.h"
  16 #include "content/public/browser/site_instance.h"
  17 #include "content/public/browser/web_contents.h"
  18 #include "content/public/common/renderer_preferences.h"
  19
  20 namespace app_window = extensions::api::app_window;
  21
  22 namespace {
  23
  24 const int kUnboundedSize = apps::ShellWindow::SizeConstraints::kUnboundedSize;
  25
  26 }
  27
  28 namespace apps {
  29
  30 AppWindowContents::AppWindowContents(ShellWindow* host)
  31     : host_(host) {
  32 }
  33
  34 AppWindowContents::~AppWindowContents() {
  35 }
  36
  37 void AppWindowContents::Initialize(Profile* profile, const GURL& url) {
  38   url_ = url;
  39
  40   extension_function_dispatcher_.reset(
  41       new ExtensionFunctionDispatcher(profile, this));
  42
  43   web_contents_.reset(content::WebContents::Create(
  44       content::WebContents::CreateParams(
  45           profile, content::SiteInstance::CreateForURL(profile, url_))));
  46
  47   content::WebContentsObserver::Observe(web_contents_.get());
  48   web_contents_->GetMutableRendererPrefs()->
  49       browser_handles_all_top_level_requests = true;
  50   web_contents_->GetRenderViewHost()->SyncRendererPrefs();
  51 }
  52
  53 void AppWindowContents::LoadContents(int32 creator_process_id) {
  54   // If the new view is in the same process as the creator, block the created
  55   // RVH from loading anything until the background page has had a chance to
  56   // do any initialization it wants. If it's a different process, the new RVH
  57   // shouldn't communicate with the background page anyway (e.g. sandboxed).
  58   if (web_contents_->GetRenderViewHost()->GetProcess()->GetID() ==
  59       creator_process_id) {
  60     SuspendRenderViewHost(web_contents_->GetRenderViewHost());
  61   } else {
  62     VLOG(1) << "ShellWindow created in new process ("
  63             << web_contents_->GetRenderViewHost()->GetProcess()->GetID()
  64             << ") != creator (" << creator_process_id
  65             << "). Routing disabled.";
  66   }
  67
  68   // TODO(jeremya): there's a bug where navigating a web contents to an
  69   // extension URL causes it to create a new RVH and discard the old (perfectly
  70   // usable) one. To work around this, we watch for a
  71   // NOTIFICATION_RENDER_VIEW_HOST_CHANGED message from the web contents (which
  72   // will be sent during LoadURL) and suspend resource requests on the new RVH
  73   // to ensure that we block the new RVH from loading anything. It should be
  74   // okay to remove the NOTIFICATION_RENDER_VIEW_HOST_CHANGED registration once
  75   // http://crbug.com/123007 is fixed.
  76   registrar_.Add(this, content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED,
  77                  content::Source<content::WebContents>(web_contents()));
  78   web_contents_->GetController().LoadURL(
  79       url_, content::Referrer(), content::PAGE_TRANSITION_LINK,
  80       std::string());
  81   registrar_.RemoveAll();
  82 }
  83
  84 void AppWindowContents::NativeWindowChanged(
  85     NativeAppWindow* native_app_window) {
  86   base::ListValue args;
  87   DictionaryValue* dictionary = new DictionaryValue();
  88   args.Append(dictionary);
  89
  90   gfx::Rect bounds = host_->GetClientBounds();
  91   app_window::Bounds update;
  92   update.left.reset(new int(bounds.x()));
  93   update.top.reset(new int(bounds.y()));
  94   update.width.reset(new int(bounds.width()));
  95   update.height.reset(new int(bounds.height()));
  96   dictionary->Set("bounds", update.ToValue().release());
  97   dictionary->SetBoolean("fullscreen",
  98                          native_app_window->IsFullscreenOrPending());
  99   dictionary->SetBoolean("minimized", native_app_window->IsMinimized());
 100   dictionary->SetBoolean("maximized", native_app_window->IsMaximized());
 101   dictionary->SetBoolean("alwaysOnTop", native_app_window->IsAlwaysOnTop());
 102
 103   const ShellWindow::SizeConstraints& size_constraints =
 104       host_->size_constraints();
 105   gfx::Size min_size = size_constraints.GetMinimumSize();
 106   gfx::Size max_size = size_constraints.GetMaximumSize();
 107   if (min_size.width() != kUnboundedSize)
 108     dictionary->SetInteger("minWidth", min_size.width());
 109   if (min_size.height() != kUnboundedSize)
 110     dictionary->SetInteger("minHeight", min_size.height());
 111   if (max_size.width() != kUnboundedSize)
 112     dictionary->SetInteger("maxWidth", max_size.width());
 113   if (max_size.height() != kUnboundedSize)
 114     dictionary->SetInteger("maxHeight", max_size.height());
 115
 116   content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
 117   rvh->Send(new ExtensionMsg_MessageInvoke(rvh->GetRoutingID(),
 118                                            host_->extension_id(),
 119                                            "app.window",
 120                                            "updateAppWindowProperties",
 121                                            args,
 122                                            false));
 123 }
 124
 125 void AppWindowContents::NativeWindowClosed() {
 126   content::RenderViewHost* rvh = web_contents_->GetRenderViewHost();
 127   rvh->Send(new ExtensionMsg_AppWindowClosed(rvh->GetRoutingID()));
 128 }
 129
 130 content::WebContents* AppWindowContents::GetWebContents() const {
 131   return web_contents_.get();
 132 }
 133
 134 void AppWindowContents::Observe(
 135     int type,
 136     const content::NotificationSource& source,
 137     const content::NotificationDetails& details) {
 138   switch (type) {
 139     case content::NOTIFICATION_RENDER_VIEW_HOST_CHANGED: {
 140       // TODO(jeremya): once http://crbug.com/123007 is fixed, we'll no longer
 141       // need to suspend resource requests here (the call in the constructor
 142       // should be enough).
 143       content::Details<std::pair<content::RenderViewHost*,
 144                                  content::RenderViewHost*> >
 145           host_details(details);
 146       if (host_details->first)
 147         SuspendRenderViewHost(host_details->second);
 148       break;
 149     }
 150     default:
 151       NOTREACHED() << "Received unexpected notification";
 152   }
 153 }
 154
 155 bool AppWindowContents::OnMessageReceived(const IPC::Message& message) {
 156   bool handled = true;
 157   IPC_BEGIN_MESSAGE_MAP(AppWindowContents, message)
 158     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
 159     IPC_MESSAGE_HANDLER(ExtensionHostMsg_UpdateDraggableRegions,
 160                         UpdateDraggableRegions)
 161     IPC_MESSAGE_UNHANDLED(handled = false)
 162   IPC_END_MESSAGE_MAP()
 163   return handled;
 164 }
 165
 166 extensions::WindowController*
 167 AppWindowContents::GetExtensionWindowController() const {
 168   return NULL;
 169 }
 170
 171 content::WebContents* AppWindowContents::GetAssociatedWebContents() const {
 172   return web_contents_.get();
 173 }
 174
 175 void AppWindowContents::OnRequest(
 176     const ExtensionHostMsg_Request_Params& params) {
 177   extension_function_dispatcher_->Dispatch(
 178       params, web_contents_->GetRenderViewHost());
 179 }
 180
 181 void AppWindowContents::UpdateDraggableRegions(
 182     const std::vector<extensions::DraggableRegion>& regions) {
 183   host_->UpdateDraggableRegions(regions);
 184 }
 185
 186 void AppWindowContents::SuspendRenderViewHost(
 187     content::RenderViewHost* rvh) {
 188   DCHECK(rvh);
 189   content::BrowserThread::PostTask(
 190       content::BrowserThread::IO, FROM_HERE,
 191       base::Bind(&content::ResourceDispatcherHost::BlockRequestsForRoute,
 192                  base::Unretained(content::ResourceDispatcherHost::Get()),
 193                  rvh->GetProcess()->GetID(), rvh->GetRoutingID()));
 194 }
 195
 196 }  // namespace apps