[cc] Forward BeginFrameAcks through RWHVAndroid / DFHAndroid.

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 423 matching lines @@
           ->OnLostResources();
     }
   }
 }
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       begin_frame_source_(nullptr),
+      latest_confirmed_begin_frame_source_id_(0),
+      latest_confirmed_begin_frame_sequence_number_(
+          cc::BeginFrameArgs::kInvalidFrameNumber),
       outstanding_begin_frame_requests_(0),
       is_showing_(!widget_host->is_hidden()),
       is_window_visible_(true),
       is_window_activity_started_(true),
       is_in_vr_(false),
       content_view_core_(nullptr),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       view_(this),
       gesture_provider_(ui::GetGestureProviderConfig(
@@ skipping 687 matching lines @@
   cc::CompositorFrameMetadata metadata = frame.metadata.Clone();
 
   bool has_content = !current_surface_size_.IsEmpty();
 
   base::Closure ack_callback =
       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);
   } else {
     delegated_frame_host_->SubmitCompositorFrame(local_surface_id,
                                                  std::move(frame));
     frame_evictor_->SwappedFrame(!host_->is_hidden());
+    AcknowledgeBeginFrame(ack);
   }
 
   if (host_->is_hidden())
     RunAckCallbacks();
 
   // As the metadata update may trigger view invalidation, always call it after
   // any potential compositor scheduling.
   OnFrameMetadataUpdated(std::move(metadata), is_transparent);
 }
 
 void RenderWidgetHostViewAndroid::DestroyDelegatedContent() {
   DCHECK(!delegated_frame_host_ ||
          delegated_frame_host_->HasDelegatedContent() ==
              frame_evictor_->HasFrame());
 
   if (!delegated_frame_host_)
     return;
 
   if (!delegated_frame_host_->HasDelegatedContent())
     return;
 
   frame_evictor_->DiscardedFrame();
   delegated_frame_host_->DestroyDelegatedContent();
 }
 
+void RenderWidgetHostViewAndroid::OnBeginFrameDidNotSwap(
+    const cc::BeginFrameAck& 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);
+}
+
 void RenderWidgetHostViewAndroid::ClearCompositorFrame() {
   DestroyDelegatedContent();
 }
 
 void RenderWidgetHostViewAndroid::SynchronousFrameMetadata(
     cc::CompositorFrameMetadata frame_metadata) {
   if (!content_view_core_)
     return;
 
   bool is_mobile_optimized = IsMobileOptimizedFrame(frame_metadata);
@@ skipping 779 matching lines @@
 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
   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_)
+  if (!host_) {
+    OnBeginFrameDidNotSwap(
+        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)
+  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));
     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(
+        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