DelegatedFrameHost should not create an ExternalBeginFrameSource

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 365 matching lines @@
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host,
                                                    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),
       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 237 matching lines @@
   NOTIMPLEMENTED();
   return static_cast<gfx::NativeViewAccessible>(NULL);
 }
 
 ui::TextInputClient* RenderWidgetHostViewAura::GetTextInputClient() {
   return this;
 }
 
 void RenderWidgetHostViewAura::SetNeedsBeginFrames(bool needs_begin_frames) {
   needs_begin_frames_ = needs_begin_frames;
-  UpdateNeedsBeginFramesInternal();
+  if (delegated_frame_host_) {
+    delegated_frame_host_->SetNeedsBeginFrames(needs_begin_frames_ ||
+                                               needs_flush_input_);
+  }
 }
 
 void RenderWidgetHostViewAura::OnSetNeedsFlushInput() {
   needs_flush_input_ = true;
-  UpdateNeedsBeginFramesInternal();
-}
-
-void RenderWidgetHostViewAura::UpdateNeedsBeginFramesInternal() {
-  if (!begin_frame_source_)
-    return;
-
-  bool needs_frame = needs_begin_frames_ || needs_flush_input_;
-  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);
+  delegated_frame_host_->SetNeedsBeginFrames(true);
 }
 
 void RenderWidgetHostViewAura::OnBeginFrame(
     const cc::BeginFrameArgs& args) {
   needs_flush_input_ = false;
   host_->FlushInput();
-  UpdateNeedsBeginFramesInternal();
+  delegated_frame_host_->SetNeedsBeginFrames(needs_begin_frames_ ||

[Eric Seckler, 2017/03/27 13:05:03]

I'd prefer to keep UpdateNeedsBeginFramesInternal, so that we define this
condition (needs_begin_frames_ || needs_flush_input_) in one place only :)

[Saman Sami, 2017/03/27 17:10:23]

Done.

+                                             needs_flush_input_);
   host_->Send(new ViewMsg_BeginFrame(host_->GetRoutingID(), args));
-  last_begin_frame_args_ = args;
-}
-
-const cc::BeginFrameArgs& RenderWidgetHostViewAura::LastUsedBeginFrameArgs()
-    const {
-  return last_begin_frame_args_;
-}
-
-void RenderWidgetHostViewAura::OnBeginFrameSourcePausedChanged(bool paused) {
-  // Only used on Android WebView.
 }
 
 RenderFrameHostImpl* RenderWidgetHostViewAura::GetFocusedFrame() {
   RenderViewHost* rvh = RenderViewHost::From(host_);
   if (!rvh)
     return nullptr;
   FrameTreeNode* focused_frame =
       rvh->GetDelegate()->GetFrameTree()->GetFocusedFrame();
   if (!focused_frame)
     return nullptr;
@@ skipping 232 matching lines @@
 
     start_edge_top.Scale(viewportToDIPScale);
     start_edge_bottom.Scale(viewportToDIPScale);
     end_edge_top.Scale(viewportToDIPScale);
     end_edge_bottom.Scale(viewportToDIPScale);
 
     selection.start.SetEdge(start_edge_top, start_edge_bottom);
     selection.end.SetEdge(end_edge_top, end_edge_bottom);
   }
 
-  cc::BeginFrameAck ack(frame.metadata.begin_frame_ack);
-
   if (delegated_frame_host_) {
     delegated_frame_host_->SwapDelegatedFrame(
         compositor_frame_sink_id, local_surface_id, std::move(frame));
   }
   selection_controller_->OnSelectionBoundsChanged(selection.start,
                                                   selection.end);
-
-  if (begin_frame_source_)
-    begin_frame_source_->DidFinishFrame(this, ack);
 }
 
 void RenderWidgetHostViewAura::OnBeginFrameDidNotSwap(
     const cc::BeginFrameAck& ack) {
-  if (begin_frame_source_)
-    begin_frame_source_->DidFinishFrame(this, ack);
+  delegated_frame_host_->BeginFrameDidNotSwap(ack);
 }
 
 void RenderWidgetHostViewAura::ClearCompositorFrame() {
   if (delegated_frame_host_)
     delegated_frame_host_->ClearDelegatedFrame();
 }
 
 void RenderWidgetHostViewAura::DidStopFlinging() {
   selection_controller_client_->OnScrollCompleted();
 }
@@ skipping 975 matching lines @@
   cc::FrameSinkId frame_sink_id =
       host_->AllocateFrameSinkId(is_guest_view_hack_);
 
   // Tests may set |delegated_frame_host_client_|.
   if (!delegated_frame_host_client_) {
     delegated_frame_host_client_ =
         base::MakeUnique<DelegatedFrameHostClientAura>(this);
   }
   delegated_frame_host_ = base::MakeUnique<DelegatedFrameHost>(
       frame_sink_id, delegated_frame_host_client_.get());
+  delegated_frame_host_->SetNeedsBeginFrames(needs_begin_frames_ ||
+                                             needs_flush_input_);
 
   // Let the page-level input event router know about our surface ID
   // namespace for surface-based hit testing.
   if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
     host_->delegate()->GetInputEventRouter()->AddFrameSinkIdOwner(
         GetFrameSinkId(), this);
   }
 }
 
 void RenderWidgetHostViewAura::UpdateCursorIfOverSelf() {
@@ skipping 410 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