[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 1193 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);
+    OnDidNotProduceFrame(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::OnDidNotProduceFrame(
     const cc::BeginFrameAck& ack) {
+  if (!delegated_frame_host_) {
+    // We are not using the browser compositor and there's no DisplayScheduler
+    // that needs to be notified about the BeginFrameAck, so we can drop it.
+    DCHECK(!using_browser_compositor_);
+    return;
+  }
+
+  delegated_frame_host_->DidNotProduceFrame(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(
+    OnDidNotProduceFrame(
         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(
-        args.source_id, args.sequence_number, confirmed, false));
+    OnDidNotProduceFrame(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_->OnBeginFrame()| 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_->OnBeginFrame();
   }
 
   if ((outstanding_begin_frame_requests_ & BEGIN_FRAME) ||
       (outstanding_begin_frame_requests_ & PERSISTENT_BEGIN_FRAME)) {
     ClearBeginFrameRequest(BEGIN_FRAME);
     SendBeginFrame(args);
   } else {
-    OnBeginFrameDidNotSwap(cc::BeginFrameAck(
-        args.source_id, args.sequence_number, args.sequence_number, false));
+    OnDidNotProduceFrame(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) {
   // The BeginFrameSources we listen to don't use this. For WebView, we signal
@@ skipping 106 matching lines @@
 
   ui::WindowAndroidCompositor* compositor = window_android->GetCompositor();
   if (!compositor)
     return;
 
   overscroll_controller_ = base::MakeUnique<OverscrollControllerAndroid>(
       overscroll_refresh_handler, compositor, view_.GetDipScale());
 }
 
 }  // namespace content