[cc] Add and plumb CFS::DidNotProduceFrame.

content/browser/renderer_host/render_widget_host_view_android.cc

 // Copyright (c) 2012 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/render_widget_host_view_android.h"
 
 #include <android/bitmap.h>
 
 #include <utility>
 
@@ skipping 1182 matching lines @@
       base::Bind(&RenderWidgetHostViewAndroid::SendReclaimCompositorResources,
                  weak_ptr_factory_.GetWeakPtr(), true /* is_swap_ack */);
 
   ack_callbacks_.push(ack_callback);
 
   cc::BeginFrameAck ack = frame.metadata.begin_frame_ack;
   if (!has_content) {
     DestroyDelegatedContent();
 
     ack.has_damage = false;
-    OnBeginFrameDidNotSwap(ack);
+    OnBeginFrameDidNotProduceFrame(ack);
   } else {
     delegated_frame_host_->SubmitCompositorFrame(local_surface_id,
                                                  std::move(frame));
     frame_evictor_->SwappedFrame(!host_->is_hidden());
     AcknowledgeBeginFrame(ack);
   }
 
   if (host_->is_hidden())
     RunAckCallbacks();
 
@@ skipping 10 matching lines @@
   if (!delegated_frame_host_)
     return;
 
   if (!delegated_frame_host_->HasDelegatedContent())
     return;
 
   frame_evictor_->DiscardedFrame();
   delegated_frame_host_->DestroyDelegatedContent();
 }
 
-void RenderWidgetHostViewAndroid::OnBeginFrameDidNotSwap(
+void RenderWidgetHostViewAndroid::OnBeginFrameDidNotProduceFrame(
     const cc::BeginFrameAck& ack) {
+  if (!delegated_frame_host_) {

[sunnyps, 2017/05/22 07:17:13]

nit: Can you add a comment about this?

[Eric Seckler, 2017/05/22 11:29:58]

Done.

+    DCHECK(!using_browser_compositor_);
+    return;
+  }
+
+  delegated_frame_host_->BeginFrameDidNotProduceFrame(ack);
   AcknowledgeBeginFrame(ack);
 }
 
 void RenderWidgetHostViewAndroid::AcknowledgeBeginFrame(
     const cc::BeginFrameAck& ack) {
   latest_confirmed_begin_frame_source_id_ = ack.source_id;
   latest_confirmed_begin_frame_sequence_number_ =
       ack.latest_confirmed_sequence_number;
   if (begin_frame_source_)
     begin_frame_source_->DidFinishFrame(this, ack);
@@ skipping 807 matching lines @@
   DCHECK(content_view_core_);
   DCHECK(using_browser_compositor_);
   RunAckCallbacks();
   overscroll_controller_.reset();
   delegated_frame_host_->DetachFromCompositor();
 }
 
 void RenderWidgetHostViewAndroid::OnBeginFrame(const cc::BeginFrameArgs& args) {
   TRACE_EVENT0("cc,benchmark", "RenderWidgetHostViewAndroid::OnBeginFrame");
   if (!host_) {
-    OnBeginFrameDidNotSwap(
+    OnBeginFrameDidNotProduceFrame(
         cc::BeginFrameAck(args.source_id, args.sequence_number,
                           cc::BeginFrameArgs::kInvalidFrameNumber, false));
     return;
   }
 
   // In sync mode, we disregard missed frame args to ensure that
   // SynchronousCompositorBrowserFilter::SyncStateAfterVSync will be called
   // during WindowAndroid::WindowBeginFrameSource::OnVSync() observer iteration.
   if (sync_compositor_ && args.type == cc::BeginFrameArgs::MISSED) {
     uint64_t confirmed = cc::BeginFrameArgs::kInvalidFrameNumber;
     if (args.source_id == latest_confirmed_begin_frame_source_id_)
       confirmed = latest_confirmed_begin_frame_sequence_number_;
-    OnBeginFrameDidNotSwap(cc::BeginFrameAck(
+    OnBeginFrameDidNotProduceFrame(cc::BeginFrameAck(
         args.source_id, args.sequence_number, confirmed, false));
     return;
   }
 
   // Update |last_begin_frame_args_| before handling
   // |outstanding_begin_frame_requests_| to prevent the BeginFrameSource from
   // sending the same MISSED args in infinite recursion. This may otherwise
   // happen if |host_->FlushInput()| causes a synchronous OnSetNeedsFlushInput()
   // which can lead to |begin_frame_source_->AddObserver()| and OnBeginFrame().
   // By setting |last_begin_frame_args_|, we indicate to the source not to send
   // the same args during |AddObserver()| again.
   last_begin_frame_args_ = args;
 
   if (outstanding_begin_frame_requests_ & FLUSH_INPUT) {
     ClearBeginFrameRequest(FLUSH_INPUT);
     host_->FlushInput();
   }
 
   if ((outstanding_begin_frame_requests_ & BEGIN_FRAME) ||
       (outstanding_begin_frame_requests_ & PERSISTENT_BEGIN_FRAME)) {
     ClearBeginFrameRequest(BEGIN_FRAME);
     SendBeginFrame(args);
   } else {
-    OnBeginFrameDidNotSwap(cc::BeginFrameAck(
+    OnBeginFrameDidNotProduceFrame(cc::BeginFrameAck(
         args.source_id, args.sequence_number, args.sequence_number, false));
   }
 }
 
 const cc::BeginFrameArgs& RenderWidgetHostViewAndroid::LastUsedBeginFrameArgs()
     const {
   return last_begin_frame_args_;
 }
 
 void RenderWidgetHostViewAndroid::OnBeginFrameSourcePausedChanged(bool paused) {
@@ skipping 107 matching lines @@
 
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor, view_.GetDipScale());
 }
 
 }  // namespace content