Send ui::LatencyInfo from renderer frame to Surface.

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 "base/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 1024 matching lines @@
   }
   DestroyDelegatedContent();
   surface_factory_.reset();
   if (!surface_returned_resources_.empty())
     SendReturnedDelegatedResources(last_output_surface_id_);
 
   last_output_surface_id_ = output_surface_id;
 }
 
 void RenderWidgetHostViewAndroid::SubmitFrame(
-    scoped_ptr<cc::DelegatedFrameData> frame_data) {
+    scoped_ptr<cc::CompositorFrame> frame) {
   cc::SurfaceManager* manager = CompositorImpl::GetSurfaceManager();
   if (manager) {
     if (!surface_factory_) {
       surface_factory_ = make_scoped_ptr(new cc::SurfaceFactory(manager, this));
     }
     if (surface_id_.is_null() ||
         texture_size_in_layer_ != current_surface_size_) {
       RemoveLayers();
       if (!surface_id_.is_null())
         surface_factory_->Destroy(surface_id_);
       surface_id_ = id_allocator_->GenerateId();
       surface_factory_->Create(surface_id_);
       layer_ = CreateDelegatedLayer();
 
       DCHECK(layer_);
 
       current_surface_size_ = texture_size_in_layer_;
       AttachLayers();
     }
-    scoped_ptr<cc::CompositorFrame> compositor_frame =
-        make_scoped_ptr(new cc::CompositorFrame());
-    compositor_frame->delegated_frame_data = frame_data.Pass();
 
     cc::SurfaceFactory::DrawCallback ack_callback =
         base::Bind(&RenderWidgetHostViewAndroid::RunAckCallbacks,
                    weak_ptr_factory_.GetWeakPtr());
-    surface_factory_->SubmitFrame(surface_id_, compositor_frame.Pass(),
-                                  ack_callback);
+    surface_factory_->SubmitFrame(surface_id_, frame.Pass(), ack_callback);
   } else {
     if (!resource_collection_.get()) {
       resource_collection_ = new cc::DelegatedFrameResourceCollection;
       resource_collection_->SetClient(this);
     }
     if (!frame_provider_.get() ||
         texture_size_in_layer_ != frame_provider_->frame_size()) {
       RemoveLayers();
       frame_provider_ = new cc::DelegatedFrameProvider(
-          resource_collection_.get(), frame_data.Pass());
+          resource_collection_.get(), frame->delegated_frame_data.Pass());
       layer_ = cc::DelegatedRendererLayer::Create(Compositor::LayerSettings(),
                                                   frame_provider_);
       AttachLayers();
     } else {
-      frame_provider_->SetFrameData(frame_data.Pass());
+      frame_provider_->SetFrameData(frame->delegated_frame_data.Pass());
     }
   }
 }
 
 void RenderWidgetHostViewAndroid::SwapDelegatedFrame(
     uint32 output_surface_id,
-    scoped_ptr<cc::DelegatedFrameData> frame_data) {
+    scoped_ptr<cc::CompositorFrame> frame) {
   CheckOutputSurfaceChanged(output_surface_id);
   bool has_content = !texture_size_in_layer_.IsEmpty();
 
   // DelegatedRendererLayerImpl applies the inverse device_scale_factor of the
   // renderer frame, assuming that the browser compositor will scale
   // it back up to device scale.  But on Android we put our browser layers in
   // physical pixels and set our browser CC device_scale_factor to 1, so this
   // suppresses the transform.  This line may need to be removed when fixing
   // http://crbug.com/384134 or http://crbug.com/310763
-  frame_data->device_scale_factor = 1.0f;
+  frame->delegated_frame_data->device_scale_factor = 1.0f;
 
   if (!has_content) {
     DestroyDelegatedContent();
   } else {
-    SubmitFrame(frame_data.Pass());
+    SubmitFrame(frame.Pass());
   }
 
   if (layer_.get()) {
     layer_->SetIsDrawable(true);
     layer_->SetContentsOpaque(true);
     layer_->SetBounds(content_size_in_layer_);
   }
 
   base::Closure ack_callback =
       base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
@@ skipping 25 matching lines @@
     LOG(ERROR) << "Non-delegated renderer path no longer supported";
     return;
   }
 
   if (locks_on_frame_count_ > 0) {
     DCHECK(HasValidFrame());
     RetainFrame(output_surface_id, frame.Pass());
     return;
   }
 
-  if (layer_.get() && layer_->layer_tree_host()) {
+  if (!CompositorImpl::GetSurfaceManager() && layer_.get() &&
+      layer_->layer_tree_host()) {
     for (size_t i = 0; i < frame->metadata.latency_info.size(); i++) {
       scoped_ptr<cc::SwapPromise> swap_promise(
           new cc::LatencyInfoSwapPromise(frame->metadata.latency_info[i]));
       layer_->layer_tree_host()->QueueSwapPromise(swap_promise.Pass());
     }
   }
 
   DCHECK(!frame->delegated_frame_data->render_pass_list.empty());
 
   cc::RenderPass* root_pass =
       frame->delegated_frame_data->render_pass_list.back();
   texture_size_in_layer_ = root_pass->output_rect.size();
   ComputeContentsSize(frame->metadata);
 
-  SwapDelegatedFrame(output_surface_id, frame->delegated_frame_data.Pass());
+  cc::CompositorFrameMetadata metadata = frame->metadata;
+
+  SwapDelegatedFrame(output_surface_id, frame.Pass());
   frame_evictor_->SwappedFrame(!host_->is_hidden());
 
   // As the metadata update may trigger view invalidation, always call it after
   // any potential compositor scheduling.
-  OnFrameMetadataUpdated(frame->metadata);
+  OnFrameMetadataUpdated(metadata);
 }
 
 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
   InternalSwapCompositorFrame(output_surface_id, frame.Pass());
 }
 
 void RenderWidgetHostViewAndroid::RetainFrame(
     uint32 output_surface_id,
@@ skipping 859 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content