[cc] Pass on BeginFrameAcks from CompositorEBFS through RWHVAura, DFH.

content/browser/renderer_host/render_widget_host_view_aura.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_aura.h"
 
 #include <set>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 369 matching lines @@
                                                    bool is_guest_view_hack)
     : host_(RenderWidgetHostImpl::From(host)),
       window_(nullptr),
       in_shutdown_(false),
       in_bounds_changed_(false),
       popup_parent_host_view_(nullptr),
       popup_child_host_view_(nullptr),
       is_loading_(false),
       has_composition_text_(false),
       begin_frame_source_(nullptr),
+      latest_confirmed_begin_frame_sequence_number_(
+          cc::BeginFrameArgs::kInvalidFrameNumber),
       needs_begin_frames_(false),
       needs_flush_input_(false),
       added_frame_observer_(false),
       cursor_visibility_state_in_renderer_(UNKNOWN),
 #if defined(OS_WIN)
       legacy_render_widget_host_HWND_(nullptr),
       legacy_window_destroyed_(false),
       virtual_keyboard_requested_(false),
 #endif
       has_snapped_to_boundary_(false),
@@ skipping 268 matching lines @@
   if (needs_frame == added_frame_observer_)
     return;
 
   added_frame_observer_ = needs_frame;
   if (needs_frame)
     begin_frame_source_->AddObserver(this);
   else
     begin_frame_source_->RemoveObserver(this);
 }
 
-void RenderWidgetHostViewAura::OnBeginFrame(
-    const cc::BeginFrameArgs& args) {
+void RenderWidgetHostViewAura::OnBeginFrame(const cc::BeginFrameArgs& args) {
+  if (args.source_id != last_begin_frame_args_.source_id) {
+    // Source changed, we don't know our freshness anymore.
+    latest_confirmed_begin_frame_sequence_number_ =
+        cc::BeginFrameArgs::kInvalidFrameNumber;
+  }
+
   needs_flush_input_ = false;
   host_->FlushInput();
   UpdateNeedsBeginFramesInternal();
   host_->Send(new ViewMsg_BeginFrame(host_->GetRoutingID(), args));
   last_begin_frame_args_ = args;
 }
 
 const cc::BeginFrameArgs& RenderWidgetHostViewAura::LastUsedBeginFrameArgs()
     const {
   return last_begin_frame_args_;
@@ skipping 253 matching lines @@
     selection.start.SetEdge(start_edge_top, start_edge_bottom);
     selection.end.SetEdge(end_edge_top, end_edge_bottom);
   }
 
   if (delegated_frame_host_) {
     delegated_frame_host_->SwapDelegatedFrame(compositor_frame_sink_id,
                                               std::move(frame));
   }
   selection_controller_->OnSelectionBoundsChanged(selection.start,
                                                   selection.end);
+
+  cc::BeginFrameAck ack(frame.metadata.begin_frame_ack);
+  DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber, ack.sequence_number);
+  // The CompositorFrame's damage was only incorporated if it wasn't skipped.
+  if (delegated_frame_host_->skipped_frames()) {
+    ack.has_damage = false;
+    ack.latest_confirmed_sequence_number =
+        latest_confirmed_begin_frame_sequence_number_;
+  } else {
+    DCHECK(ack.has_damage);
+    latest_confirmed_begin_frame_sequence_number_ =
+        ack.latest_confirmed_sequence_number;
+  }
+
+  if (begin_frame_source_)
+    begin_frame_source_->DidFinishFrame(this, ack);

[Eric Seckler, 2017/03/14 11:13:41]

+fsamuel, +brianderson:

Regarding the discussion about surface synchronization, here's what I think
might be a problem in the approach here:

DFH::SwapDelegatedFrame submits the CompositorFrame to the Surface(Factory),
where it may get stuck in pending state. DisplayScheduler won't see the surface
damage until it becomes active.

The BeginFrameAck, however, is sent separately (this LOC) so will be visible to
DisplayScheduler immediately. When we change DisplayScheduler to using these
acks for deciding when to draw&swap, it might try to draw&swap before the
pending CompositorFrame becomes active (i.e. before the damage is actually on
the surface corresponding to the BeginFrameAck).

Is that a problem?

[Fady Samuel, 2017/03/14 11:31:38]

Could we do this from Surface::ActivateFrame then, instead?

+}
+
+void RenderWidgetHostViewAura::OnBeginFrameDidNotDraw(
+    const cc::BeginFrameAck& ack) {
+  DCHECK_LE(cc::BeginFrameArgs::kStartingFrameNumber, ack.sequence_number);
+  DCHECK(!ack.has_damage);
+  cc::BeginFrameAck modified_ack = ack;
+  if (delegated_frame_host_->skipped_frames()) {
+    // If DelegatedFrameHost skipped the last frame(s), we need to wait for a
+    // newly submitted CompositorFrame before confirming newer sequence numbers.
+    modified_ack.latest_confirmed_sequence_number =
+        latest_confirmed_begin_frame_sequence_number_;
+  }
+  if (begin_frame_source_)
+    begin_frame_source_->DidFinishFrame(this, modified_ack);
 }
 
 void RenderWidgetHostViewAura::ClearCompositorFrame() {
   if (delegated_frame_host_)
     delegated_frame_host_->ClearDelegatedFrame();
 }
 
 void RenderWidgetHostViewAura::DidStopFlinging() {
   selection_controller_client_->OnScrollCompleted();
 }
@@ skipping 1413 matching lines @@
 
 void RenderWidgetHostViewAura::SetPopupChild(
     RenderWidgetHostViewAura* popup_child_host_view) {
   popup_child_host_view_ = popup_child_host_view;
   event_handler_->SetPopupChild(
       popup_child_host_view,
       popup_child_host_view ? popup_child_host_view->event_handler() : nullptr);
 }
 
 }  // namespace content