[cc] Add and plumb CFS::DidNotProduceFrame.

content/browser/renderer_host/delegated_frame_host.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 "content/browser/renderer_host/delegated_frame_host.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 201 matching lines @@
   return target_view->TransformPointToLocalCoordSpace(
       point, cc::SurfaceId(frame_sink_id_, local_surface_id_),
       transformed_point);
 }
 
 void DelegatedFrameHost::SetNeedsBeginFrames(bool needs_begin_frames) {
   needs_begin_frame_ = needs_begin_frames;
   support_->SetNeedsBeginFrame(needs_begin_frames);
 }
 
-void DelegatedFrameHost::BeginFrameDidNotSwap(const cc::BeginFrameAck& ack) {
+void DelegatedFrameHost::DidNotProduceFrame(const cc::BeginFrameAck& ack) {
   DidFinishFrame(ack);
 
   cc::BeginFrameAck modified_ack = ack;
   if (skipped_frames_) {
     // If we skipped the last frame(s), we didn't incorporate the last
     // CompositorFrame's damage, so need to wait for the next one before
     // confirming newer sequence numbers.
     modified_ack.has_damage = false;
     modified_ack.latest_confirmed_sequence_number =
         latest_confirmed_begin_frame_sequence_number_;
   }
 
-  support_->BeginFrameDidNotSwap(modified_ack);
+  support_->DidNotProduceFrame(modified_ack);
 }
 
 bool DelegatedFrameHost::ShouldSkipFrame(const gfx::Size& size_in_dip) {
   if (!resize_lock_)
     return false;
   // Allow a single renderer frame through even though there's a resize lock
   // currently in place.
   if (allow_one_renderer_frame_during_resize_lock_) {
     allow_one_renderer_frame_during_resize_lock_ = false;
     return false;
@@ skipping 168 matching lines @@
     cc::ReturnedResourceArray resources;
     cc::TransferableResource::ReturnResources(frame.resource_list, &resources);
 
     skipped_latency_info_list_.insert(skipped_latency_info_list_.end(),
                                       frame.metadata.latency_info.begin(),
                                       frame.metadata.latency_info.end());
 
     renderer_compositor_frame_sink_->DidReceiveCompositorFrameAck(resources);
 
     skipped_frames_ = true;
-    BeginFrameDidNotSwap(ack);
+    DidNotProduceFrame(ack);
     return;
   }
 
   // If we are allowing one renderer frame through, this would ensure the frame
   // gets through even if we regrab the lock after the UI compositor makes one
   // frame. If the renderer frame beats the UI compositor, then we don't need to
   // allow any more, though.
   allow_one_renderer_frame_during_resize_lock_ = false;
 
   if (skipped_frames_) {
@@ skipping 427 matching lines @@
   }
 
   if (!skipped_frames_) {
     latest_confirmed_begin_frame_source_id_ = ack.source_id;
     latest_confirmed_begin_frame_sequence_number_ =
         ack.latest_confirmed_sequence_number;
   }
 }
 
 }  // namespace content