[android] Make RWHVAndroid a BeginFrameObserver.

ui/android/delegated_frame_host_android.cc

 // Copyright 2016 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 "ui/android/delegated_frame_host_android.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/surface_layer.h"
@@ skipping 33 matching lines @@
 void CopyOutputRequestCallback(
     scoped_refptr<cc::Layer> readback_layer,
     cc::CopyOutputRequest::CopyOutputRequestCallback result_callback,
     std::unique_ptr<cc::CopyOutputResult> copy_output_result) {
   readback_layer->RemoveFromParent();
   result_callback.Run(std::move(copy_output_result));
 }
 
 }  // namespace
 
-DelegatedFrameHostAndroid::DelegatedFrameHostAndroid(
-    ui::ViewAndroid* view,
-    SkColor background_color,
-    ReturnResourcesCallback return_resources_callback)
+DelegatedFrameHostAndroid::DelegatedFrameHostAndroid(ui::ViewAndroid* view,
+                                                     SkColor background_color,
+                                                     Client* client)
     : frame_sink_id_(
           ui::ContextProviderFactory::GetInstance()->AllocateFrameSinkId()),
       view_(view),
-      return_resources_callback_(return_resources_callback),
+      client_(client),
       background_layer_(cc::SolidColorLayer::Create()) {
   DCHECK(view_);
-  DCHECK(!return_resources_callback_.is_null());
+  DCHECK(client_);
 
   surface_manager_ =
       ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
   surface_id_allocator_.reset(new cc::SurfaceIdAllocator());
   surface_manager_->RegisterFrameSinkId(frame_sink_id_);
   surface_factory_ = base::WrapUnique(
       new cc::SurfaceFactory(frame_sink_id_, surface_manager_, this));
 
   background_layer_->SetBackgroundColor(background_color);
   view_->GetLayer()->AddChild(background_layer_);
@@ skipping 141 matching lines @@
   if (!registered_parent_frame_sink_id_.is_valid())
     return;
   surface_manager_->UnregisterSurfaceFactoryClient(frame_sink_id_);
   surface_manager_->UnregisterFrameSinkHierarchy(
       registered_parent_frame_sink_id_, frame_sink_id_);
   registered_parent_frame_sink_id_ = cc::FrameSinkId();
 }
 
 void DelegatedFrameHostAndroid::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
-  return_resources_callback_.Run(resources);
+  client_->ReturnResources(resources);
 }
 
 void DelegatedFrameHostAndroid::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
-  // TODO(enne): hook this up instead of making RWHVAndroid a
-  // WindowAndroidObserver.
+  client_->SetBeginFrameSource(begin_frame_source);
 }
 
 void DelegatedFrameHostAndroid::UpdateBackgroundLayer() {
   // The background layer draws in 2 cases:
   // 1) When we don't have any content from the renderer.
   // 2) When the bounds of the content received from the renderer does not match
   // the desired content bounds.
   bool background_is_drawable = false;
 
   if (current_frame_) {
     float device_scale_factor = display::Screen::GetScreen()
         ->GetDisplayNearestWindow(view_).device_scale_factor();
     gfx::Size content_size_in_dip = gfx::ConvertSizeToDIP(
         device_scale_factor, current_frame_->surface_size);
     background_is_drawable =
         content_size_in_dip.width() < container_size_in_dip_.width() ||
         content_size_in_dip.height() < container_size_in_dip_.height();
   } else {
     background_is_drawable = true;
   }
 
   background_layer_->SetIsDrawable(background_is_drawable);
 }
 
 }  // namespace ui