content/browser/renderer_host/render_widget_helper.cc

   1 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_helper.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/lazy_instance.h"
  10 #include "base/posix/eintr_wrapper.h"
  11 #include "base/threading/thread.h"
  12 #include "base/threading/thread_restrictions.h"
  13 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
  14 #include "content/browser/gpu/gpu_surface_tracker.h"
  15 #include "content/browser/loader/resource_dispatcher_host_impl.h"
  16 #include "content/browser/renderer_host/render_process_host_impl.h"
  17 #include "content/browser/renderer_host/render_view_host_impl.h"
  18 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
  19 #include "content/common/view_messages.h"
  20
  21 namespace content {
  22 namespace {
  23
  24 typedef std::map<int, RenderWidgetHelper*> WidgetHelperMap;
  25 base::LazyInstance<WidgetHelperMap> g_widget_helpers =
  26     LAZY_INSTANCE_INITIALIZER;
  27
  28 void AddWidgetHelper(int render_process_id,
  29                      const scoped_refptr<RenderWidgetHelper>& widget_helper) {
  30   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  31   // We don't care if RenderWidgetHelpers overwrite an existing process_id. Just
  32   // want this to be up to date.
  33   g_widget_helpers.Get()[render_process_id] = widget_helper.get();
  34 }
  35
  36 }  // namespace
  37
  38 RenderWidgetHelper::RenderWidgetHelper()
  39     : render_process_id_(-1),
  40       resource_dispatcher_host_(NULL) {
  41 }
  42
  43 RenderWidgetHelper::~RenderWidgetHelper() {
  44   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  45
  46   // Delete this RWH from the map if it is found.
  47   WidgetHelperMap& widget_map = g_widget_helpers.Get();
  48   WidgetHelperMap::iterator it = widget_map.find(render_process_id_);
  49   if (it != widget_map.end() && it->second == this)
  50     widget_map.erase(it);
  51
  52 #if defined(OS_POSIX) && !defined(OS_ANDROID)
  53   ClearAllocatedDIBs();
  54 #endif
  55 }
  56
  57 void RenderWidgetHelper::Init(
  58     int render_process_id,
  59     ResourceDispatcherHostImpl* resource_dispatcher_host) {
  60   render_process_id_ = render_process_id;
  61   resource_dispatcher_host_ = resource_dispatcher_host;
  62
  63   BrowserThread::PostTask(
  64       BrowserThread::IO, FROM_HERE,
  65       base::Bind(&AddWidgetHelper,
  66                  render_process_id_, make_scoped_refptr(this)));
  67 }
  68
  69 int RenderWidgetHelper::GetNextRoutingID() {
  70   return next_routing_id_.GetNext() + 1;
  71 }
  72
  73 // static
  74 RenderWidgetHelper* RenderWidgetHelper::FromProcessHostID(
  75     int render_process_host_id) {
  76   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  77   WidgetHelperMap::const_iterator ci = g_widget_helpers.Get().find(
  78       render_process_host_id);
  79   return (ci == g_widget_helpers.Get().end())? NULL : ci->second;
  80 }
  81
  82 void RenderWidgetHelper::ResumeDeferredNavigation(
  83     const GlobalRequestID& request_id) {
  84   BrowserThread::PostTask(
  85       BrowserThread::IO, FROM_HERE,
  86       base::Bind(&RenderWidgetHelper::OnResumeDeferredNavigation,
  87                  this,
  88                  request_id));
  89 }
  90
  91 void RenderWidgetHelper::ResumeResponseDeferredAtStart(
  92     const GlobalRequestID& request_id) {
  93   BrowserThread::PostTask(
  94       BrowserThread::IO,
  95       FROM_HERE,
  96       base::Bind(&RenderWidgetHelper::OnResumeResponseDeferredAtStart,
  97                  this,
  98                  request_id));
  99 }
 100
 101 void RenderWidgetHelper::ResumeRequestsForView(int route_id) {
 102   // We only need to resume blocked requests if we used a valid route_id.
 103   // See CreateNewWindow.
 104   if (route_id != MSG_ROUTING_NONE) {
 105     BrowserThread::PostTask(
 106         BrowserThread::IO, FROM_HERE,
 107         base::Bind(&RenderWidgetHelper::OnResumeRequestsForView,
 108             this, route_id));
 109   }
 110 }
 111
 112 void RenderWidgetHelper::OnResumeDeferredNavigation(
 113     const GlobalRequestID& request_id) {
 114   resource_dispatcher_host_->ResumeDeferredNavigation(request_id);
 115 }
 116
 117 void RenderWidgetHelper::OnResumeResponseDeferredAtStart(
 118     const GlobalRequestID& request_id) {
 119   resource_dispatcher_host_->ResumeResponseDeferredAtStart(request_id);
 120 }
 121
 122 void RenderWidgetHelper::CreateNewWindow(
 123     const ViewHostMsg_CreateWindow_Params& params,
 124     bool no_javascript_access,
 125     base::ProcessHandle render_process,
 126     int* route_id,
 127     int* main_frame_route_id,
 128     int* surface_id,
 129     SessionStorageNamespace* session_storage_namespace) {
 130   if (params.opener_suppressed || no_javascript_access) {
 131     // If the opener is supppressed or script access is disallowed, we should
 132     // open the window in a new BrowsingInstance, and thus a new process. That
 133     // means the current renderer process will not be able to route messages to
 134     // it. Because of this, we will immediately show and navigate the window
 135     // in OnCreateWindowOnUI, using the params provided here.
 136     *route_id = MSG_ROUTING_NONE;
 137     *main_frame_route_id = MSG_ROUTING_NONE;
 138     *surface_id = 0;
 139   } else {
 140     *route_id = GetNextRoutingID();
 141     *main_frame_route_id = GetNextRoutingID();
 142     *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
 143         render_process_id_, *route_id);
 144     // Block resource requests until the view is created, since the HWND might
 145     // be needed if a response ends up creating a plugin.
 146     resource_dispatcher_host_->BlockRequestsForRoute(
 147         render_process_id_, *route_id);
 148     resource_dispatcher_host_->BlockRequestsForRoute(
 149         render_process_id_, *main_frame_route_id);
 150   }
 151
 152   BrowserThread::PostTask(
 153       BrowserThread::UI, FROM_HERE,
 154       base::Bind(&RenderWidgetHelper::OnCreateWindowOnUI,
 155                  this, params, *route_id, *main_frame_route_id,
 156                  make_scoped_refptr(session_storage_namespace)));
 157 }
 158
 159 void RenderWidgetHelper::OnCreateWindowOnUI(
 160     const ViewHostMsg_CreateWindow_Params& params,
 161     int route_id,
 162     int main_frame_route_id,
 163     SessionStorageNamespace* session_storage_namespace) {
 164   RenderViewHostImpl* host =
 165       RenderViewHostImpl::FromID(render_process_id_, params.opener_id);
 166   if (host)
 167     host->CreateNewWindow(route_id, main_frame_route_id, params,
 168         session_storage_namespace);
 169 }
 170
 171 void RenderWidgetHelper::OnResumeRequestsForView(int route_id) {
 172   resource_dispatcher_host_->ResumeBlockedRequestsForRoute(
 173       render_process_id_, route_id);
 174 }
 175
 176 void RenderWidgetHelper::CreateNewWidget(int opener_id,
 177                                          blink::WebPopupType popup_type,
 178                                          int* route_id,
 179                                          int* surface_id) {
 180   *route_id = GetNextRoutingID();
 181   *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
 182       render_process_id_, *route_id);
 183   BrowserThread::PostTask(
 184       BrowserThread::UI, FROM_HERE,
 185       base::Bind(
 186           &RenderWidgetHelper::OnCreateWidgetOnUI, this, opener_id, *route_id,
 187           popup_type));
 188 }
 189
 190 void RenderWidgetHelper::CreateNewFullscreenWidget(int opener_id,
 191                                                    int* route_id,
 192                                                    int* surface_id) {
 193   *route_id = GetNextRoutingID();
 194   *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
 195       render_process_id_, *route_id);
 196   BrowserThread::PostTask(
 197       BrowserThread::UI, FROM_HERE,
 198       base::Bind(
 199           &RenderWidgetHelper::OnCreateFullscreenWidgetOnUI, this,
 200           opener_id, *route_id));
 201 }
 202
 203 void RenderWidgetHelper::OnCreateWidgetOnUI(
 204     int opener_id, int route_id, blink::WebPopupType popup_type) {
 205   RenderViewHostImpl* host = RenderViewHostImpl::FromID(
 206       render_process_id_, opener_id);
 207   if (host)
 208     host->CreateNewWidget(route_id, popup_type);
 209 }
 210
 211 void RenderWidgetHelper::OnCreateFullscreenWidgetOnUI(int opener_id,
 212                                                       int route_id) {
 213   RenderViewHostImpl* host = RenderViewHostImpl::FromID(
 214       render_process_id_, opener_id);
 215   if (host)
 216     host->CreateNewFullscreenWidget(route_id);
 217 }
 218
 219 #if defined(OS_POSIX) && !defined(OS_ANDROID)
 220 void RenderWidgetHelper::AllocTransportDIB(uint32 size,
 221                                            bool cache_in_browser,
 222                                            TransportDIB::Handle* result) {
 223   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
 224   if (!shared_memory->CreateAnonymous(size)) {
 225     result->fd = -1;
 226     result->auto_close = false;
 227     return;
 228   }
 229
 230   shared_memory->GiveToProcess(0 /* pid, not needed */, result);
 231
 232   if (cache_in_browser) {
 233     // Keep a copy of the file descriptor around
 234     base::AutoLock locked(allocated_dibs_lock_);
 235     allocated_dibs_[shared_memory->id()] = dup(result->fd);
 236   }
 237 }
 238
 239 void RenderWidgetHelper::FreeTransportDIB(TransportDIB::Id dib_id) {
 240   base::AutoLock locked(allocated_dibs_lock_);
 241
 242   const std::map<TransportDIB::Id, int>::iterator
 243     i = allocated_dibs_.find(dib_id);
 244
 245   if (i != allocated_dibs_.end()) {
 246     if (IGNORE_EINTR(close(i->second)) < 0)
 247       PLOG(ERROR) << "close";
 248     allocated_dibs_.erase(i);
 249   } else {
 250     DLOG(WARNING) << "Renderer asked us to free unknown transport DIB";
 251   }
 252 }
 253
 254 void RenderWidgetHelper::ClearAllocatedDIBs() {
 255   for (std::map<TransportDIB::Id, int>::iterator
 256        i = allocated_dibs_.begin(); i != allocated_dibs_.end(); ++i) {
 257     if (IGNORE_EINTR(close(i->second)) < 0)
 258       PLOG(ERROR) << "close: " << i->first;
 259   }
 260
 261   allocated_dibs_.clear();
 262 }
 263 #endif
 264
 265 }  // namespace content