Don't submit frames with no render passes in cc tests

cc/surfaces/surface.cc

 // Copyright 2014 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 "cc/surfaces/surface.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 66 matching lines @@
     // If there are no blockers, then immediately activate the frame.
     ActivateFrame(FrameData(std::move(frame), callback, will_draw_callback));
   }
 
   // Returns resources for the previous pending frame.
   UnrefFrameResourcesAndRunDrawCallback(std::move(previous_pending_frame_data));
 }
 
 void Surface::RequestCopyOfOutput(
     std::unique_ptr<CopyOutputRequest> copy_request) {
-  if (!active_frame_data_ ||
-      active_frame_data_->frame.render_pass_list.empty()) {
+  if (!active_frame_data_) {
     copy_request->SendEmptyResult();
     return;
   }
 
   std::vector<std::unique_ptr<CopyOutputRequest>>& copy_requests =
       active_frame_data_->frame.render_pass_list.back()->copy_requests;
 
   if (copy_request->has_source()) {
     const base::UnguessableToken& source = copy_request->source();
     // Remove existing CopyOutputRequests made on the Surface by the same
@@ skipping 61 matching lines @@
 }
 
 // A frame is activated if all its Surface ID dependences are active or a
 // deadline has hit and the frame was forcibly activated by the display
 // compositor.
 void Surface::ActivateFrame(FrameData frame_data) {
   DCHECK(factory_);
 
   // Save root pass copy requests.
   std::vector<std::unique_ptr<CopyOutputRequest>> old_copy_requests;
-  if (active_frame_data_ &&
-      !active_frame_data_->frame.render_pass_list.empty()) {
+  if (active_frame_data_) {
     std::swap(old_copy_requests,
               active_frame_data_->frame.render_pass_list.back()->copy_requests);
   }
 
   ClearCopyRequests();
 
   TakeLatencyInfo(&frame_data.frame.metadata.latency_info);
 
   base::Optional<FrameData> previous_frame_data = std::move(active_frame_data_);
 
   active_frame_data_ = std::move(frame_data);
 
   for (auto& copy_request : old_copy_requests)
     RequestCopyOfOutput(std::move(copy_request));
 
-  // Empty frames shouldn't be drawn and shouldn't contribute damage, so don't
-  // increment frame index for them.
-  if (!active_frame_data_->frame.render_pass_list.empty())
-    ++frame_index_;
+  ++frame_index_;
 
   previous_frame_surface_id_ = surface_id();
 
   UnrefFrameResourcesAndRunDrawCallback(std::move(previous_frame_data));
 
   for (auto& observer : observers_)
     observer.OnSurfaceActivated(this);
 }
 
 void Surface::UpdateBlockingSurfaces(bool has_previous_pending_frame,
@@ skipping 145 matching lines @@
     frame->metadata.latency_info.swap(*latency_info);
     return;
   }
   std::copy(frame->metadata.latency_info.begin(),
             frame->metadata.latency_info.end(),
             std::back_inserter(*latency_info));
   frame->metadata.latency_info.clear();
 }
 
 }  // namespace cc