Remove SendBeginFramesToChildren plumbing

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 350 matching lines @@
 // RenderWidgetHostViewAura, public:
 
 RenderWidgetHostViewAura::RenderWidgetHostViewAura(RenderWidgetHost* host,
                                                    bool is_guest_view_hack)
     : host_(RenderWidgetHostImpl::From(host)),
       window_(nullptr),
       delegated_frame_host_(new DelegatedFrameHost(this)),
       in_shutdown_(false),
       in_bounds_changed_(false),
       is_fullscreen_(false),
-      popup_parent_host_view_(NULL),
-      popup_child_host_view_(NULL),
+      popup_parent_host_view_(nullptr),
+      popup_child_host_view_(nullptr),
       is_loading_(false),
       text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       text_input_flags_(0),
       can_compose_inline_(true),
       has_composition_text_(false),
       accept_return_character_(false),
       last_swapped_software_frame_scale_factor_(1.f),
-      paint_canvas_(NULL),
+      begin_frame_source_(nullptr),
+      observing_begin_frame_source_(false),
+      paint_canvas_(nullptr),
       synthetic_move_sent_(false),
       cursor_visibility_state_in_renderer_(UNKNOWN),
 #if defined(OS_WIN)
-      legacy_render_widget_host_HWND_(NULL),
+      legacy_render_widget_host_HWND_(nullptr),
       legacy_window_destroyed_(false),
 #endif
       has_snapped_to_boundary_(false),
       is_guest_view_hack_(is_guest_view_hack),
-      begin_frame_observer_proxy_(this),
       set_focus_on_mouse_down_or_key_event_(false),
       device_scale_factor_(0.0f),
       disable_input_event_router_for_testing_(false),
       weak_ptr_factory_(this) {
   if (!is_guest_view_hack_)
     host_->SetView(this);
 
   // Let the page-level input event router know about our surface ID
   // namespace for surface-based hit testing.
   if (host_->delegate() && host_->delegate()->GetInputEventRouter()) {
@@ skipping 252 matching lines @@
 
   NOTIMPLEMENTED();
   return static_cast<gfx::NativeViewAccessible>(NULL);
 }
 
 ui::TextInputClient* RenderWidgetHostViewAura::GetTextInputClient() {
   return this;
 }
 
 void RenderWidgetHostViewAura::OnSetNeedsBeginFrames(bool needs_begin_frames) {
-  begin_frame_observer_proxy_.SetNeedsBeginFrames(needs_begin_frames);
+  if (observing_begin_frame_source_ == needs_begin_frames)
+    return;
+
+  observing_begin_frame_source_ = needs_begin_frames;

[no sievers, 2016/04/07 20:35:35]

nit: I'm wondering if calling it |needs_begin_frames_| rather than
|observing_begin_frame_source_| is a bit less confusing, since it might actually
be |true| when we aren't actually observing in the case where there was no BFS.

+  if (begin_frame_source_) {
+    if (observing_begin_frame_source_)
+      begin_frame_source_->AddObserver(this);
+    else
+      begin_frame_source_->RemoveObserver(this);
+  }
 }
 
-void RenderWidgetHostViewAura::SendBeginFrame(const cc::BeginFrameArgs& args) {
+void RenderWidgetHostViewAura::OnBeginFrame(const cc::BeginFrameArgs& args) {
   delegated_frame_host_->SetVSyncParameters(args.frame_time, args.interval);

[sunnyps, 2016/04/07 23:57:54]

nit: Does this belong in DelegatedFrameHost::OnBeginFrame?

[enne (OOO), 2016/04/14 18:12:16]

Not unless you think the DelegatedFrameHost should also be observing the
BeginFrameSource just for this?

[sunnyps, 2016/04/19 01:00:22]

Sorry for the late reply. I confused this with OnSetNeedsBeginFrames.

   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) {
+  // Ignored for now.  If the begin frame source is paused, the renderer
+  // doesn't need to be informed about it and will just not receive more
+  // begin frames.
+}
+
+void RenderWidgetHostViewAura::AsValueInto(
+    base::trace_event::TracedValue* dict) const {
+  // TODO(enne): implement me?
 }
 
 void RenderWidgetHostViewAura::SetKeyboardFocus() {
 #if defined(OS_WIN)
   if (CanFocus()) {
     aura::WindowTreeHost* host = window_->GetHost();
     if (host) {
       gfx::AcceleratedWidget hwnd = host->GetAcceleratedWidget();
       if (!(::GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_NOACTIVATE))
         ::SetFocus(hwnd);
@@ skipping 1965 matching lines @@
 
 #if defined(OS_WIN)
   // The parent may have changed here. Ensure that the legacy window is
   // reparented accordingly.
   if (legacy_render_widget_host_HWND_)
     legacy_render_widget_host_HWND_->UpdateParent(
         reinterpret_cast<HWND>(GetNativeViewId()));
 #endif
 
   delegated_frame_host_->SetCompositor(window_->GetHost()->compositor());
-  if (window_->GetHost()->compositor())
-    begin_frame_observer_proxy_.SetCompositor(window_->GetHost()->compositor());
 }
 
 void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   aura::client::CursorClient* cursor_client =
       aura::client::GetCursorClient(window_->GetRootWindow());
   if (cursor_client)
     cursor_client->RemoveObserver(this);
 
   DetachFromInputMethod();
 
   window_->GetHost()->RemoveObserver(this);
   delegated_frame_host_->ResetCompositor();
-  begin_frame_observer_proxy_.ResetCompositor();
 
 #if defined(OS_WIN)
   // Update the legacy window's parent temporarily to the desktop window. It
   // will eventually get reparented to the right root.
   if (legacy_render_widget_host_HWND_)
     legacy_render_widget_host_HWND_->UpdateParent(::GetDesktopWindow());
 #endif
 }
 
 void RenderWidgetHostViewAura::DetachFromInputMethod() {
@@ skipping 222 matching lines @@
 void RenderWidgetHostViewAura::DelegatedFrameHostOnLostCompositorResources() {
   host_->ScheduleComposite();
 }
 
 void RenderWidgetHostViewAura::DelegatedFrameHostUpdateVSyncParameters(
     const base::TimeTicks& timebase,
     const base::TimeDelta& interval) {
   host_->UpdateVSyncParameters(timebase, interval);
 }
 
+void RenderWidgetHostViewAura::SetBeginFrameSource(
+    cc::BeginFrameSource* source) {
+  if (begin_frame_source_ && observing_begin_frame_source_)
+    begin_frame_source_->RemoveObserver(this);
+  begin_frame_source_ = source;
+  if (begin_frame_source_ && observing_begin_frame_source_)
+    begin_frame_source_->AddObserver(this);
+}
+
 void RenderWidgetHostViewAura::OnDidNavigateMainFrameToNewPage() {
   ui::GestureRecognizer::Get()->CancelActiveTouches(window_);
 }
 
 void RenderWidgetHostViewAura::LockCompositingSurface() {
   NOTIMPLEMENTED();
 }
 
 void RenderWidgetHostViewAura::UnlockCompositingSurface() {
   NOTIMPLEMENTED();
 }
 
 uint32_t RenderWidgetHostViewAura::GetSurfaceIdNamespace() {
   return delegated_frame_host_->GetSurfaceIdNamespace();
 }
 
 cc::SurfaceId RenderWidgetHostViewAura::SurfaceIdForTesting() const {
   return delegated_frame_host_->SurfaceIdForTesting();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewBase, public:
 
 // static
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content