Home | History | Annotate | Download | only in renderer_host 
      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 #if defined(OS_WIN)
      6 #include <windows.h>
      7 #endif
      8 
      9 #include "content/browser/renderer_host/gpu_message_filter.h"
     10 
     11 #include "base/bind.h"
     12 #include "base/command_line.h"
     13 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
     14 #include "content/browser/gpu/gpu_process_host.h"
     15 #include "content/browser/gpu/gpu_surface_tracker.h"
     16 #include "content/browser/renderer_host/render_widget_helper.h"
     17 #include "content/common/gpu/gpu_messages.h"
     18 #include "content/port/browser/render_widget_host_view_frame_subscriber.h"
     19 #include "content/public/common/content_switches.h"
     20 #include "gpu/command_buffer/service/gpu_switches.h"
     21 
     22 namespace content {
     23 
     24 struct GpuMessageFilter::CreateViewCommandBufferRequest {
     25   CreateViewCommandBufferRequest(
     26       int32 surface_id_,
     27       const GPUCreateCommandBufferConfig& init_params_,
     28       IPC::Message* reply_)
     29       : surface_id(surface_id_),
     30         init_params(init_params_),
     31         reply(reply_) {
     32   }
     33   int32 surface_id;
     34   GPUCreateCommandBufferConfig init_params;
     35   IPC::Message* reply;
     36 };
     37 
     38 struct GpuMessageFilter::FrameSubscription {
     39   FrameSubscription(
     40       int in_route_id,
     41       scoped_ptr<RenderWidgetHostViewFrameSubscriber> in_subscriber)
     42       : route_id(in_route_id),
     43         surface_id(0),
     44         subscriber(in_subscriber.Pass()),
     45         factory(subscriber.get()) {
     46   }
     47 
     48   int route_id;
     49   int surface_id;
     50   scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber;
     51   base::WeakPtrFactory<RenderWidgetHostViewFrameSubscriber> factory;
     52 };
     53 
     54 GpuMessageFilter::GpuMessageFilter(int render_process_id,
     55                                    RenderWidgetHelper* render_widget_helper)
     56     : gpu_process_id_(0),
     57       render_process_id_(render_process_id),
     58       share_contexts_(false),
     59       render_widget_helper_(render_widget_helper),
     60       weak_ptr_factory_(this) {
     61   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     62 
     63 #if defined(USE_AURA) || defined(OS_ANDROID)
     64   // We use the GPU process for UI on Aura, and we need to share renderer GL
     65   // contexts with the compositor context.
     66   share_contexts_ = true;
     67 #else
     68   // Share contexts when compositing webview plugin or using share groups
     69   // for asynchronous texture uploads.
     70   if (!CommandLine::ForCurrentProcess()->HasSwitch(
     71           switches::kDisableBrowserPluginCompositing) ||
     72       CommandLine::ForCurrentProcess()->HasSwitch(
     73           switches::kEnableShareGroupAsyncTextureUpload))
     74     share_contexts_ = true;
     75 #endif
     76 }
     77 
     78 GpuMessageFilter::~GpuMessageFilter() {
     79   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     80   EndAllFrameSubscriptions();
     81 }
     82 
     83 bool GpuMessageFilter::OnMessageReceived(
     84     const IPC::Message& message,
     85     bool* message_was_ok) {
     86   bool handled = true;
     87   IPC_BEGIN_MESSAGE_MAP_EX(GpuMessageFilter, message, *message_was_ok)
     88     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_EstablishGpuChannel,
     89                                     OnEstablishGpuChannel)
     90     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuHostMsg_CreateViewCommandBuffer,
     91                                     OnCreateViewCommandBuffer)
     92     IPC_MESSAGE_UNHANDLED(handled = false)
     93   IPC_END_MESSAGE_MAP_EX()
     94   return handled;
     95 }
     96 
     97 void GpuMessageFilter::SurfaceUpdated(int32 surface_id) {
     98   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     99   typedef std::vector<linked_ptr<CreateViewCommandBufferRequest> > RequestList;
    100   RequestList retry_requests;
    101   retry_requests.swap(pending_requests_);
    102   for (RequestList::iterator it = retry_requests.begin();
    103       it != retry_requests.end(); ++it) {
    104     if ((*it)->surface_id != surface_id) {
    105       pending_requests_.push_back(*it);
    106     } else {
    107       linked_ptr<CreateViewCommandBufferRequest> request = *it;
    108       OnCreateViewCommandBuffer(request->surface_id,
    109                                 request->init_params,
    110                                 request->reply);
    111     }
    112   }
    113 }
    114 
    115 void GpuMessageFilter::BeginFrameSubscription(
    116     int route_id,
    117     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
    118   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    119   linked_ptr<FrameSubscription> subscription(
    120       new FrameSubscription(route_id, subscriber.Pass()));
    121   BeginFrameSubscriptionInternal(subscription);
    122 }
    123 
    124 void GpuMessageFilter::EndFrameSubscription(int route_id) {
    125   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    126   FrameSubscriptionList frame_subscription_list;
    127   frame_subscription_list.swap(frame_subscription_list_);
    128   for (FrameSubscriptionList::iterator it = frame_subscription_list.begin();
    129        it != frame_subscription_list.end(); ++it) {
    130     if ((*it)->route_id != route_id)
    131       frame_subscription_list_.push_back(*it);
    132     else
    133       EndFrameSubscriptionInternal(*it);
    134   }
    135 }
    136 
    137 void GpuMessageFilter::OnEstablishGpuChannel(
    138     CauseForGpuLaunch cause_for_gpu_launch,
    139     IPC::Message* reply) {
    140   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    141 
    142   // TODO(apatrick): Eventually, this will return the route ID of a
    143   // GpuProcessStub, from which the renderer process will create a
    144   // GpuProcessProxy. The renderer will use the proxy for all subsequent
    145   // communication with the GPU process. This means if the GPU process
    146   // terminates, the renderer process will not find itself unknowingly sending
    147   // IPCs to a newly launched GPU process. Also, I will rename this function
    148   // to something like OnCreateGpuProcess.
    149   GpuProcessHost* host = GpuProcessHost::FromID(gpu_process_id_);
    150   if (!host) {
    151     host = GpuProcessHost::Get(GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
    152                                cause_for_gpu_launch);
    153     if (!host) {
    154       reply->set_reply_error();
    155       Send(reply);
    156       return;
    157     }
    158 
    159     gpu_process_id_ = host->host_id();
    160 
    161     // Apply all frame subscriptions to the new GpuProcessHost.
    162     BeginAllFrameSubscriptions();
    163   }
    164 
    165   host->EstablishGpuChannel(
    166       render_process_id_,
    167       share_contexts_,
    168       base::Bind(&GpuMessageFilter::EstablishChannelCallback,
    169                  weak_ptr_factory_.GetWeakPtr(),
    170                  reply));
    171 }
    172 
    173 void GpuMessageFilter::OnCreateViewCommandBuffer(
    174     int32 surface_id,
    175     const GPUCreateCommandBufferConfig& init_params,
    176     IPC::Message* reply) {
    177   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    178 
    179   GpuSurfaceTracker* surface_tracker = GpuSurfaceTracker::Get();
    180   gfx::GLSurfaceHandle compositing_surface;
    181 
    182   int renderer_id = 0;
    183   int render_widget_id = 0;
    184   bool result = surface_tracker->GetRenderWidgetIDForSurface(
    185       surface_id, &renderer_id, &render_widget_id);
    186   if (result && renderer_id == render_process_id_) {
    187     compositing_surface = surface_tracker->GetSurfaceHandle(surface_id);
    188   } else {
    189     DLOG(ERROR) << "Renderer " << render_process_id_
    190                 << " tried to access a surface for renderer " << renderer_id;
    191   }
    192 
    193   if (compositing_surface.parent_gpu_process_id &&
    194       compositing_surface.parent_gpu_process_id != gpu_process_id_) {
    195     // If the current handle for the surface is using a different (older) gpu
    196     // host, it means the GPU process died and we need to wait until the UI
    197     // re-allocates the surface in the new process.
    198     linked_ptr<CreateViewCommandBufferRequest> request(
    199         new CreateViewCommandBufferRequest(surface_id, init_params, reply));
    200     pending_requests_.push_back(request);
    201     return;
    202   }
    203 
    204   GpuProcessHost* host = GpuProcessHost::FromID(gpu_process_id_);
    205   if (!host || compositing_surface.is_null()) {
    206     // TODO(apatrick): Eventually, this IPC message will be routed to a
    207     // GpuProcessStub with a particular routing ID. The error will be set if
    208     // the GpuProcessStub with that routing ID is not in the MessageRouter.
    209     reply->set_reply_error();
    210     Send(reply);
    211     return;
    212   }
    213 
    214   host->CreateViewCommandBuffer(
    215       compositing_surface,
    216       surface_id,
    217       render_process_id_,
    218       init_params,
    219       base::Bind(&GpuMessageFilter::CreateCommandBufferCallback,
    220                  weak_ptr_factory_.GetWeakPtr(),
    221                  reply));
    222 }
    223 
    224 void GpuMessageFilter::EstablishChannelCallback(
    225     IPC::Message* reply,
    226     const IPC::ChannelHandle& channel,
    227     const gpu::GPUInfo& gpu_info) {
    228   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    229 
    230   GpuHostMsg_EstablishGpuChannel::WriteReplyParams(
    231       reply, render_process_id_, channel, gpu_info);
    232   Send(reply);
    233 }
    234 
    235 void GpuMessageFilter::CreateCommandBufferCallback(
    236     IPC::Message* reply, int32 route_id) {
    237   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    238   GpuHostMsg_CreateViewCommandBuffer::WriteReplyParams(reply, route_id);
    239   Send(reply);
    240 }
    241 
    242 void GpuMessageFilter::BeginAllFrameSubscriptions() {
    243   FrameSubscriptionList frame_subscription_list;
    244   frame_subscription_list.swap(frame_subscription_list_);
    245   for (FrameSubscriptionList::iterator it = frame_subscription_list.begin();
    246        it != frame_subscription_list.end(); ++it) {
    247     BeginFrameSubscriptionInternal(*it);
    248   }
    249 }
    250 
    251 void GpuMessageFilter::EndAllFrameSubscriptions() {
    252   for (FrameSubscriptionList::iterator it = frame_subscription_list_.begin();
    253        it != frame_subscription_list_.end(); ++it) {
    254     EndFrameSubscriptionInternal(*it);
    255   }
    256   frame_subscription_list_.clear();
    257 }
    258 
    259 void GpuMessageFilter::BeginFrameSubscriptionInternal(
    260     linked_ptr<FrameSubscription> subscription) {
    261   if (!subscription->surface_id) {
    262     GpuSurfaceTracker* surface_tracker = GpuSurfaceTracker::Get();
    263     subscription->surface_id = surface_tracker->LookupSurfaceForRenderer(
    264         render_process_id_, subscription->route_id);
    265 
    266     // If the surface ID cannot be found this subscription is dropped.
    267     if (!subscription->surface_id)
    268       return;
    269   }
    270   frame_subscription_list_.push_back(subscription);
    271 
    272   // Frame subscriber is owned by this object, but it is shared with
    273   // GpuProcessHost. GpuProcessHost can be destroyed in the case of crashing
    274   // and we do not get a signal. This object can also be destroyed independent
    275   // of GpuProcessHost. To ensure that GpuProcessHost does not reference a
    276   // deleted frame subscriber, a weak reference is shared.
    277   GpuProcessHost* host = GpuProcessHost::FromID(gpu_process_id_);
    278   if (!host)
    279     return;
    280   host->BeginFrameSubscription(subscription->surface_id,
    281                                subscription->factory.GetWeakPtr());
    282 }
    283 
    284 void GpuMessageFilter::EndFrameSubscriptionInternal(
    285     linked_ptr<FrameSubscription> subscription) {
    286   GpuProcessHost* host = GpuProcessHost::FromID(gpu_process_id_);
    287 
    288   // An empty surface ID means subscription has never started in GpuProcessHost
    289   // so it is not necessary to end it.
    290   if (!host || !subscription->surface_id)
    291     return;
    292 
    293   // Note that GpuProcessHost here might not be the same one that frame
    294   // subscription has applied.
    295   host->EndFrameSubscription(subscription->surface_id);
    296 }
    297 
    298 }  // namespace content
    299