src/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_surface_tracker.h"
  14 #include "content/browser/loader/resource_dispatcher_host_impl.h"
  15 #include "content/browser/renderer_host/render_process_host_impl.h"
  16 #include "content/browser/renderer_host/render_view_host_impl.h"
  17 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
  18 #include "content/common/view_messages.h"
  19
  20 namespace content {
  21 namespace {
  22
  23 typedef std::map<int, RenderWidgetHelper*> WidgetHelperMap;
  24 base::LazyInstance<WidgetHelperMap> g_widget_helpers =
  25     LAZY_INSTANCE_INITIALIZER;
  26
  27 void AddWidgetHelper(int render_process_id,
  28                      const scoped_refptr<RenderWidgetHelper>& widget_helper) {
  29   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  30   // We don't care if RenderWidgetHelpers overwrite an existing process_id. Just
  31   // want this to be up to date.
  32   g_widget_helpers.Get()[render_process_id] = widget_helper.get();
  33 }
  34
  35 }  // namespace
  36
  37 // A helper used with DidReceiveBackingStoreMsg that we hold a pointer to in
  38 // pending_paints_.
  39 class RenderWidgetHelper::BackingStoreMsgProxy {
  40  public:
  41   BackingStoreMsgProxy(RenderWidgetHelper* h, const IPC::Message& m);
  42   ~BackingStoreMsgProxy();
  43   void Run();
  44   void Cancel() { cancelled_ = true; }
  45
  46   const IPC::Message& message() const { return message_; }
  47
  48  private:
  49   scoped_refptr<RenderWidgetHelper> helper_;
  50   IPC::Message message_;
  51   bool cancelled_;  // If true, then the message will not be dispatched.
  52
  53   DISALLOW_COPY_AND_ASSIGN(BackingStoreMsgProxy);
  54 };
  55
  56 RenderWidgetHelper::BackingStoreMsgProxy::BackingStoreMsgProxy(
  57     RenderWidgetHelper* h, const IPC::Message& m)
  58     : helper_(h),
  59       message_(m),
  60       cancelled_(false) {
  61 }
  62
  63 RenderWidgetHelper::BackingStoreMsgProxy::~BackingStoreMsgProxy() {
  64   // If the paint message was never dispatched, then we need to let the
  65   // helper know that we are going away.
  66   if (!cancelled_ && helper_.get())
  67     helper_->OnDiscardBackingStoreMsg(this);
  68 }
  69
  70 void RenderWidgetHelper::BackingStoreMsgProxy::Run() {
  71   if (!cancelled_) {
  72     helper_->OnDispatchBackingStoreMsg(this);
  73     helper_ = NULL;
  74   }
  75 }
  76
  77 RenderWidgetHelper::RenderWidgetHelper()
  78     : render_process_id_(-1),
  79 #if defined(OS_WIN)
  80       event_(CreateEvent(NULL, FALSE /* auto-reset */, FALSE, NULL)),
  81 #elif defined(OS_POSIX)
  82       event_(false /* auto-reset */, false),
  83 #endif
  84       resource_dispatcher_host_(NULL) {
  85 }
  86
  87 RenderWidgetHelper::~RenderWidgetHelper() {
  88   DCHECK_CURRENTLY_ON(BrowserThread::IO);
  89
  90   // Delete this RWH from the map if it is found.
  91   WidgetHelperMap& widget_map = g_widget_helpers.Get();
  92   WidgetHelperMap::iterator it = widget_map.find(render_process_id_);
  93   if (it != widget_map.end() && it->second == this)
  94     widget_map.erase(it);
  95
  96   // The elements of pending_paints_ each hold an owning reference back to this
  97   // object, so we should not be destroyed unless pending_paints_ is empty!
  98   DCHECK(pending_paints_.empty());
  99
 100 #if defined(OS_POSIX) && !defined(OS_ANDROID)
 101   ClearAllocatedDIBs();
 102 #endif
 103 }
 104
 105 void RenderWidgetHelper::Init(
 106     int render_process_id,
 107     ResourceDispatcherHostImpl* resource_dispatcher_host) {
 108   render_process_id_ = render_process_id;
 109   resource_dispatcher_host_ = resource_dispatcher_host;
 110
 111   BrowserThread::PostTask(
 112       BrowserThread::IO, FROM_HERE,
 113       base::Bind(&AddWidgetHelper,
 114                  render_process_id_, make_scoped_refptr(this)));
 115 }
 116
 117 int RenderWidgetHelper::GetNextRoutingID() {
 118   return next_routing_id_.GetNext() + 1;
 119 }
 120
 121 // static
 122 RenderWidgetHelper* RenderWidgetHelper::FromProcessHostID(
 123     int render_process_host_id) {
 124   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 125   WidgetHelperMap::const_iterator ci = g_widget_helpers.Get().find(
 126       render_process_host_id);
 127   return (ci == g_widget_helpers.Get().end())? NULL : ci->second;
 128 }
 129
 130 void RenderWidgetHelper::ResumeDeferredNavigation(
 131     const GlobalRequestID& request_id) {
 132   BrowserThread::PostTask(
 133       BrowserThread::IO, FROM_HERE,
 134       base::Bind(&RenderWidgetHelper::OnResumeDeferredNavigation,
 135                  this,
 136                  request_id));
 137 }
 138
 139 bool RenderWidgetHelper::WaitForBackingStoreMsg(
 140     int render_widget_id, const base::TimeDelta& max_delay, IPC::Message* msg) {
 141   base::TimeTicks time_start = base::TimeTicks::Now();
 142
 143   for (;;) {
 144     BackingStoreMsgProxy* proxy = NULL;
 145     {
 146       base::AutoLock lock(pending_paints_lock_);
 147
 148       BackingStoreMsgProxyMap::iterator it =
 149           pending_paints_.find(render_widget_id);
 150       if (it != pending_paints_.end()) {
 151         BackingStoreMsgProxyQueue &queue = it->second;
 152         DCHECK(!queue.empty());
 153         proxy = queue.front();
 154
 155         // Flag the proxy as cancelled so that when it is run as a task it will
 156         // do nothing.
 157         proxy->Cancel();
 158
 159         queue.pop_front();
 160         if (queue.empty())
 161           pending_paints_.erase(it);
 162       }
 163     }
 164
 165     if (proxy) {
 166       *msg = proxy->message();
 167       DCHECK(msg->routing_id() == render_widget_id);
 168       return true;
 169     }
 170
 171     // Calculate the maximum amount of time that we are willing to sleep.
 172     base::TimeDelta max_sleep_time =
 173         max_delay - (base::TimeTicks::Now() - time_start);
 174     if (max_sleep_time <= base::TimeDelta::FromMilliseconds(0))
 175       break;
 176
 177     base::ThreadRestrictions::ScopedAllowWait allow_wait;
 178     event_.TimedWait(max_sleep_time);
 179   }
 180
 181   return false;
 182 }
 183
 184 void RenderWidgetHelper::ResumeRequestsForView(int route_id) {
 185   // We only need to resume blocked requests if we used a valid route_id.
 186   // See CreateNewWindow.
 187   if (route_id != MSG_ROUTING_NONE) {
 188     BrowserThread::PostTask(
 189         BrowserThread::IO, FROM_HERE,
 190         base::Bind(&RenderWidgetHelper::OnResumeRequestsForView,
 191             this, route_id));
 192   }
 193 }
 194
 195 void RenderWidgetHelper::DidReceiveBackingStoreMsg(const IPC::Message& msg) {
 196   int render_widget_id = msg.routing_id();
 197
 198   BackingStoreMsgProxy* proxy = new BackingStoreMsgProxy(this, msg);
 199   {
 200     base::AutoLock lock(pending_paints_lock_);
 201
 202     pending_paints_[render_widget_id].push_back(proxy);
 203   }
 204
 205   // Notify anyone waiting on the UI thread that there is a new entry in the
 206   // proxy map.  If they don't find the entry they are looking for, then they
 207   // will just continue waiting.
 208   event_.Signal();
 209
 210   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 211       base::Bind(&BackingStoreMsgProxy::Run, base::Owned(proxy)));
 212 }
 213
 214 void RenderWidgetHelper::OnDiscardBackingStoreMsg(BackingStoreMsgProxy* proxy) {
 215   const IPC::Message& msg = proxy->message();
 216
 217   // Remove the proxy from the map now that we are going to handle it normally.
 218   {
 219     base::AutoLock lock(pending_paints_lock_);
 220
 221     BackingStoreMsgProxyMap::iterator it =
 222         pending_paints_.find(msg.routing_id());
 223     DCHECK(it != pending_paints_.end());
 224     BackingStoreMsgProxyQueue &queue = it->second;
 225     DCHECK(queue.front() == proxy);
 226
 227     queue.pop_front();
 228     if (queue.empty())
 229       pending_paints_.erase(it);
 230   }
 231 }
 232
 233 void RenderWidgetHelper::OnDispatchBackingStoreMsg(
 234     BackingStoreMsgProxy* proxy) {
 235   OnDiscardBackingStoreMsg(proxy);
 236
 237   // It is reasonable for the host to no longer exist.
 238   RenderProcessHost* host = RenderProcessHost::FromID(render_process_id_);
 239   if (host)
 240     host->OnMessageReceived(proxy->message());
 241 }
 242
 243 void RenderWidgetHelper::OnResumeDeferredNavigation(
 244     const GlobalRequestID& request_id) {
 245   resource_dispatcher_host_->ResumeDeferredNavigation(request_id);
 246 }
 247
 248 void RenderWidgetHelper::CreateNewWindow(
 249     const ViewHostMsg_CreateWindow_Params& params,
 250     bool no_javascript_access,
 251     base::ProcessHandle render_process,
 252     int* route_id,
 253     int* main_frame_route_id,
 254     int* surface_id,
 255     SessionStorageNamespace* session_storage_namespace) {
 256   if (params.opener_suppressed || no_javascript_access) {
 257     // If the opener is supppressed or script access is disallowed, we should
 258     // open the window in a new BrowsingInstance, and thus a new process. That
 259     // means the current renderer process will not be able to route messages to
 260     // it. Because of this, we will immediately show and navigate the window
 261     // in OnCreateWindowOnUI, using the params provided here.
 262     *route_id = MSG_ROUTING_NONE;
 263     *main_frame_route_id = MSG_ROUTING_NONE;
 264     *surface_id = 0;
 265   } else {
 266     *route_id = GetNextRoutingID();
 267     *main_frame_route_id = GetNextRoutingID();
 268     *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
 269         render_process_id_, *route_id);
 270     // Block resource requests until the view is created, since the HWND might
 271     // be needed if a response ends up creating a plugin.
 272     resource_dispatcher_host_->BlockRequestsForRoute(
 273         render_process_id_, *route_id);
 274     resource_dispatcher_host_->BlockRequestsForRoute(
 275         render_process_id_, *main_frame_route_id);
 276   }
 277
 278   BrowserThread::PostTask(
 279       BrowserThread::UI, FROM_HERE,
 280       base::Bind(&RenderWidgetHelper::OnCreateWindowOnUI,
 281                  this, params, *route_id, *main_frame_route_id,
 282                  make_scoped_refptr(session_storage_namespace)));
 283 }
 284
 285 void RenderWidgetHelper::OnCreateWindowOnUI(
 286     const ViewHostMsg_CreateWindow_Params& params,
 287     int route_id,
 288     int main_frame_route_id,
 289     SessionStorageNamespace* session_storage_namespace) {
 290   RenderViewHostImpl* host =
 291       RenderViewHostImpl::FromID(render_process_id_, params.opener_id);
 292   if (host)
 293     host->CreateNewWindow(route_id, main_frame_route_id, params,
 294         session_storage_namespace);
 295 }
 296
 297 void RenderWidgetHelper::OnResumeRequestsForView(int route_id) {
 298   resource_dispatcher_host_->ResumeBlockedRequestsForRoute(
 299       render_process_id_, route_id);
 300 }
 301
 302 void RenderWidgetHelper::CreateNewWidget(int opener_id,
 303                                          blink::WebPopupType popup_type,
 304                                          int* route_id,
 305                                          int* surface_id) {
 306   *route_id = GetNextRoutingID();
 307   *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
 308       render_process_id_, *route_id);
 309   BrowserThread::PostTask(
 310       BrowserThread::UI, FROM_HERE,
 311       base::Bind(
 312           &RenderWidgetHelper::OnCreateWidgetOnUI, this, opener_id, *route_id,
 313           popup_type));
 314 }
 315
 316 void RenderWidgetHelper::CreateNewFullscreenWidget(int opener_id,
 317                                                    int* route_id,
 318                                                    int* surface_id) {
 319   *route_id = GetNextRoutingID();
 320   *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
 321       render_process_id_, *route_id);
 322   BrowserThread::PostTask(
 323       BrowserThread::UI, FROM_HERE,
 324       base::Bind(
 325           &RenderWidgetHelper::OnCreateFullscreenWidgetOnUI, this,
 326           opener_id, *route_id));
 327 }
 328
 329 void RenderWidgetHelper::OnCreateWidgetOnUI(
 330     int opener_id, int route_id, blink::WebPopupType popup_type) {
 331   RenderViewHostImpl* host = RenderViewHostImpl::FromID(
 332       render_process_id_, opener_id);
 333   if (host)
 334     host->CreateNewWidget(route_id, popup_type);
 335 }
 336
 337 void RenderWidgetHelper::OnCreateFullscreenWidgetOnUI(int opener_id,
 338                                                       int route_id) {
 339   RenderViewHostImpl* host = RenderViewHostImpl::FromID(
 340       render_process_id_, opener_id);
 341   if (host)
 342     host->CreateNewFullscreenWidget(route_id);
 343 }
 344
 345 #if defined(OS_POSIX) && !defined(OS_ANDROID)
 346 void RenderWidgetHelper::AllocTransportDIB(uint32 size,
 347                                            bool cache_in_browser,
 348                                            TransportDIB::Handle* result) {
 349   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
 350   if (!shared_memory->CreateAnonymous(size)) {
 351     result->fd = -1;
 352     result->auto_close = false;
 353     return;
 354   }
 355
 356   shared_memory->GiveToProcess(0 /* pid, not needed */, result);
 357
 358   if (cache_in_browser) {
 359     // Keep a copy of the file descriptor around
 360     base::AutoLock locked(allocated_dibs_lock_);
 361     allocated_dibs_[shared_memory->id()] = dup(result->fd);
 362   }
 363 }
 364
 365 void RenderWidgetHelper::FreeTransportDIB(TransportDIB::Id dib_id) {
 366   base::AutoLock locked(allocated_dibs_lock_);
 367
 368   const std::map<TransportDIB::Id, int>::iterator
 369     i = allocated_dibs_.find(dib_id);
 370
 371   if (i != allocated_dibs_.end()) {
 372     if (IGNORE_EINTR(close(i->second)) < 0)
 373       PLOG(ERROR) << "close";
 374     allocated_dibs_.erase(i);
 375   } else {
 376     DLOG(WARNING) << "Renderer asked us to free unknown transport DIB";
 377   }
 378 }
 379
 380 void RenderWidgetHelper::ClearAllocatedDIBs() {
 381   for (std::map<TransportDIB::Id, int>::iterator
 382        i = allocated_dibs_.begin(); i != allocated_dibs_.end(); ++i) {
 383     if (IGNORE_EINTR(close(i->second)) < 0)
 384       PLOG(ERROR) << "close: " << i->first;
 385   }
 386
 387   allocated_dibs_.clear();
 388 }
 389 #endif
 390
 391 }  // namespace content