Reject CompositorFrames with no render passes when deserializing

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 "cc/ipc/cc_param_traits.h"
@@ skipping 274 matching lines @@
     if (use_in_process_zero_copy_software_draw_) {
       DCHECK(sk_canvas_for_draw);
       compositor_frame_sink_->DemandDrawSw(sk_canvas_for_draw);
     } else {
       DCHECK(!sk_canvas_for_draw);
       DoDemandDrawSw(params);
     }
   }
   if (inside_receive_) {
     // Did not swap.
-    SendDemandDrawSwReply(false, cc::CompositorFrame(), reply_message);
+    SendDemandDrawSwReply(base::nullopt, reply_message);
     inside_receive_ = false;
   }
 }
 
 void SynchronousCompositorProxy::DoDemandDrawSw(
     const SyncCompositorDemandDrawSwParams& params) {
   DCHECK(compositor_frame_sink_);
   DCHECK(software_draw_shm_->zeroed);
   software_draw_shm_->zeroed = false;
 
@@ skipping 10 matching lines @@
   canvas.clipRect(gfx::RectToSkRect(params.clip));
   canvas.concat(params.transform.matrix());
 
   compositor_frame_sink_->DemandDrawSw(&canvas);
 }
 
 void SynchronousCompositorProxy::SubmitCompositorFrameSw(
     cc::CompositorFrame frame) {
   DCHECK(inside_receive_);
   DCHECK(software_draw_reply_);
-  SendDemandDrawSwReply(true, std::move(frame), software_draw_reply_);
+  SendDemandDrawSwReply(std::move(frame.metadata), software_draw_reply_);
   inside_receive_ = false;
 }
 
 void SynchronousCompositorProxy::SendDemandDrawSwReply(
-    bool success,
-    cc::CompositorFrame frame,
+    base::Optional<cc::CompositorFrameMetadata> metadata,
     IPC::Message* reply_message) {
   SyncCompositorCommonRendererParams common_renderer_params;
   PopulateCommonParams(&common_renderer_params);
   SyncCompositorMsg_DemandDrawSw::WriteReplyParams(
-      reply_message, success, common_renderer_params, frame);
+      reply_message, common_renderer_params, metadata);
   Send(reply_message);
 }
 
 void SynchronousCompositorProxy::SubmitCompositorFrame(
     uint32_t compositor_frame_sink_id,
     cc::CompositorFrame frame) {
   // Verify that exactly one of these is true.
   DCHECK(hardware_draw_reply_async_ || hardware_draw_reply_ ||
          software_draw_reply_);
   DCHECK(!((hardware_draw_reply_ && software_draw_reply_) ||
@@ skipping 28 matching lines @@
 
 void SynchronousCompositorProxy::SetScroll(
     const gfx::ScrollOffset& new_total_scroll_offset) {
   if (total_scroll_offset_ == new_total_scroll_offset)
     return;
   total_scroll_offset_ = new_total_scroll_offset;
   input_handler_proxy_->SynchronouslySetRootScrollOffset(total_scroll_offset_);
 }
 
 }  // namespace content