sync compositor: Handle context loss

content/renderer/android/synchronous_compositor_proxy.cc

 // Copyright 2015 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 "content/renderer/android/synchronous_compositor_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/memory/shared_memory.h"
 #include "content/common/android/sync_compositor_messages.h"
 #include "content/common/cc_messages.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/skia_util.h"
 
 namespace content {
 
 SynchronousCompositorProxy::SynchronousCompositorProxy(
     int routing_id,
     IPC::Sender* sender,
-    SynchronousCompositorOutputSurface* output_surface,
     SynchronousCompositorExternalBeginFrameSource* begin_frame_source,
     ui::SynchronousInputHandlerProxy* input_handler_proxy,
     InputHandlerManagerClient::Handler* handler)
     : routing_id_(routing_id),
       sender_(sender),
-      output_surface_(output_surface),
       begin_frame_source_(begin_frame_source),
       input_handler_proxy_(input_handler_proxy),
       input_handler_(handler),
       use_in_process_zero_copy_software_draw_(
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kSingleProcess)),
+      output_surface_(nullptr),
       inside_receive_(false),
       hardware_draw_reply_(nullptr),
       software_draw_reply_(nullptr),
       bytes_limit_(0u),
       version_(0u),
       page_scale_factor_(0.f),
       min_page_scale_factor_(0.f),
       max_page_scale_factor_(0.f),
       need_animate_scroll_(false),
       need_invalidate_count_(0u),
       need_begin_frame_(false),
       did_activate_pending_tree_count_(0u) {
-  DCHECK(output_surface_);
   DCHECK(begin_frame_source_);
   DCHECK(input_handler_proxy_);
   DCHECK(input_handler_);
-  output_surface_->SetSyncClient(this);
-  output_surface_->SetTreeActivationCallback(
-      base::Bind(&SynchronousCompositorProxy::DidActivatePendingTree,
-                 base::Unretained(this)));
   begin_frame_source_->SetClient(this);
   input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(this);
 }
 
 SynchronousCompositorProxy::~SynchronousCompositorProxy() {
-  output_surface_->SetSyncClient(nullptr);
-  output_surface_->SetTreeActivationCallback(base::Closure());
+  SetOutputSurface(nullptr);
   begin_frame_source_->SetClient(nullptr);
   input_handler_proxy_->SetOnlySynchronouslyAnimateRootFlings(nullptr);
 }
 
+void SynchronousCompositorProxy::SetOutputSurface(
+    SynchronousCompositorOutputSurface* output_surface) {
+  DCHECK_NE(output_surface_, output_surface);
+  if (output_surface_) {
+    output_surface_->SetSyncClient(nullptr);
+    output_surface_->SetTreeActivationCallback(base::Closure());
+  }
+  output_surface_ = output_surface;
+  if (output_surface_) {
+    output_surface_->SetSyncClient(this);
+    output_surface_->SetTreeActivationCallback(
+        base::Bind(&SynchronousCompositorProxy::DidActivatePendingTree,
+                   base::Unretained(this)));
+    output_surface_->SetMemoryPolicy(bytes_limit_);

[Tobias Sargeant, 2016/03/23 10:10:55]

I guess previously we would never have called SetMemoryPolicy(0) initially on
the output surface (even if the browser sent that). Doesn't look like a problem
(in fact maybe this is more correct), but I thought I'd flag it.

[boliu, 2016/03/23 15:52:53]

Same behavior either way.

+  }
+}
+
 void SynchronousCompositorProxy::SetNeedsSynchronousAnimateInput() {
   need_animate_scroll_ = true;
   Invalidate();
 }
 
 void SynchronousCompositorProxy::UpdateRootLayerState(
     const gfx::ScrollOffset& total_scroll_offset,
     const gfx::ScrollOffset& max_scroll_offset,
     const gfx::SizeF& scrollable_size,
     float page_scale_factor,
@@ skipping 29 matching lines @@
   SendAsyncRendererStateIfNeeded();
 }
 
 void SynchronousCompositorProxy::DidActivatePendingTree() {
   ++did_activate_pending_tree_count_;
   SendAsyncRendererStateIfNeeded();
   DeliverMessages();
 }
 
 void SynchronousCompositorProxy::DeliverMessages() {
+  DCHECK(output_surface_);
   std::vector<scoped_ptr<IPC::Message>> messages;
   output_surface_->GetMessagesToDeliver(&messages);
   for (auto& msg : messages) {
     Send(msg.release());
   }
 }
 
 void SynchronousCompositorProxy::SendAsyncRendererStateIfNeeded() {
   if (inside_receive_)
     return;
@@ skipping 69 matching lines @@
 void SynchronousCompositorProxy::DemandDrawHw(
     const SyncCompositorCommonBrowserParams& common_params,
     const SyncCompositorDemandDrawHwParams& params,
     IPC::Message* reply_message) {
   DCHECK(!inside_receive_);
   DCHECK(reply_message);
 
   inside_receive_ = true;
   ProcessCommonParams(common_params);
 
-  {
+  if (output_surface_) {
     base::AutoReset<IPC::Message*> scoped_hardware_draw_reply(
         &hardware_draw_reply_, reply_message);
     output_surface_->DemandDrawHw(params.surface_size, params.transform,
                                   params.viewport, params.clip,
                                   params.viewport_rect_for_tile_priority,
                                   params.transform_for_tile_priority);
   }
 
   if (inside_receive_) {
     // Did not swap.
@@ skipping 75 matching lines @@
   software_draw_shm_->zeroed = true;
 }
 
 void SynchronousCompositorProxy::DemandDrawSw(
     const SyncCompositorCommonBrowserParams& common_params,
     const SyncCompositorDemandDrawSwParams& params,
     IPC::Message* reply_message) {
   DCHECK(!inside_receive_);
   inside_receive_ = true;
   ProcessCommonParams(common_params);
-  {
+  if (output_surface_) {
     base::AutoReset<IPC::Message*> scoped_software_draw_reply(
         &software_draw_reply_, reply_message);
     if (use_in_process_zero_copy_software_draw_) {
       DCHECK(g_sk_canvas_for_draw);
       output_surface_->DemandDrawSw(g_sk_canvas_for_draw);
     } else {
       DCHECK(!g_sk_canvas_for_draw);
       DoDemandDrawSw(params);
     }
   }
   if (inside_receive_) {
     // Did not swap.
     cc::CompositorFrame empty_frame;
     SendDemandDrawSwReply(false, &empty_frame, reply_message);
     inside_receive_ = false;
   } else {
     DeliverMessages();
   }
 }
 
 void SynchronousCompositorProxy::DoDemandDrawSw(
     const SyncCompositorDemandDrawSwParams& params) {
+  DCHECK(output_surface_);
   DCHECK(software_draw_shm_->zeroed);
   software_draw_shm_->zeroed = false;
 
   SkImageInfo info =
       SkImageInfo::MakeN32Premul(params.size.width(), params.size.height());
   size_t stride = info.minRowBytes();
   size_t buffer_size = info.getSafeSize(stride);
   DCHECK_EQ(software_draw_shm_->buffer_size, buffer_size);
 
   SkBitmap bitmap;
@@ skipping 51 matching lines @@
   SyncCompositorCommonRendererParams params;
   PopulateCommonParams(&params);
   Send(new SyncCompositorHostMsg_OverScroll(routing_id_, params,
                                             did_overscroll_params));
 }
 
 void SynchronousCompositorProxy::ProcessCommonParams(
     const SyncCompositorCommonBrowserParams& common_params) {
   if (bytes_limit_ != common_params.bytes_limit) {
     bytes_limit_ = common_params.bytes_limit;
-    output_surface_->SetMemoryPolicy(bytes_limit_);
+    if (output_surface_)
+      output_surface_->SetMemoryPolicy(bytes_limit_);
   }
   if (common_params.update_root_scroll_offset &&
       total_scroll_offset_ != common_params.root_scroll_offset) {
     total_scroll_offset_ = common_params.root_scroll_offset;
     input_handler_proxy_->SynchronouslySetRootScrollOffset(
         total_scroll_offset_);
   }
   begin_frame_source_->SetBeginFrameSourcePaused(
       common_params.begin_frame_source_paused);
-  if (!common_params.ack.resources.empty()) {
+  if (output_surface_ && !common_params.ack.resources.empty()) {
     output_surface_->ReturnResources(
         common_params.output_surface_id_for_returned_resources,
         common_params.ack);
   }
 }
 
 }  // namespace content