Switch Display to use ResourceProvider and *Renderer directly.

cc/surfaces/display.cc

 // Copyright 2014 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.
 
 #ifndef CC_SURFACES_DISPLAY_H_
 #define CC_SURFACES_DISPLAY_H_
 
 #include "cc/surfaces/display.h"
 
 #include "base/message_loop/message_loop.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/output/gl_renderer.h"
+#include "cc/output/software_renderer.h"
 #include "cc/surfaces/display_client.h"
 #include "cc/surfaces/surface.h"
-#include "ui/gfx/frame_time.h"
 
 namespace cc {
+static ResourceProvider::ResourceId ResourceRemapHelper(
+    bool* invalid_frame,
+    const ResourceProvider::ResourceIdMap& child_to_parent_map,
+    ResourceProvider::ResourceIdArray* resources_in_frame,
+    ResourceProvider::ResourceId id) {
+  ResourceProvider::ResourceIdMap::const_iterator it =
+      child_to_parent_map.find(id);
+  if (it == child_to_parent_map.end()) {
+    *invalid_frame = true;
+    return 0;
+  }
+
+  DCHECK_EQ(it->first, id);
+  ResourceProvider::ResourceId remapped_id = it->second;
+  resources_in_frame->push_back(id);
+  return remapped_id;
+}
 
 Display::Display(DisplayClient* client,
                  SurfaceManager* manager,
                  SharedBitmapManager* bitmap_manager)
-    : scheduled_draw_(false),
-      client_(client),
+    : client_(client),
       manager_(manager),
       aggregator_(manager),
-      bitmap_manager_(bitmap_manager),
-      schedule_draw_factory_(this) {
+      bitmap_manager_(bitmap_manager) {
 }
 
 Display::~Display() {
 }
 
 void Display::Resize(const gfx::Size& size) {
   current_surface_.reset(new Surface(manager_, this, size));
 }
 
 bool Display::Draw() {
   if (!current_surface_)
     return false;
 
+  if (!output_surface_) {
+    scoped_ptr<OutputSurface> output_surface = client_->CreateOutputSurface();

[jamesr, 2014/06/09 02:39:27]

this block is long enough to be its own function

+    if (!output_surface->BindToClient(this))
+      return false;
+
+    int highp_threshold_min = 0;
+    bool use_rgba_4444_texture_format = false;
+    size_t id_allocation_chunk_size = 1;
+    bool use_distance_field_text = false;
+    scoped_ptr<ResourceProvider> resource_provider =
+        ResourceProvider::Create(output_surface.get(),
+                                 bitmap_manager_,
+                                 highp_threshold_min,
+                                 use_rgba_4444_texture_format,
+                                 id_allocation_chunk_size,
+                                 use_distance_field_text);
+    if (!resource_provider)
+      return false;
+
+    LayerTreeSettings settings;
+    if (output_surface->context_provider()) {
+      TextureMailboxDeleter* texture_mailbox_deleter = NULL;
+      scoped_ptr<GLRenderer> renderer =
+          GLRenderer::Create(this,
+                             &settings,
+                             output_surface.get(),
+                             resource_provider.get(),
+                             texture_mailbox_deleter,
+                             highp_threshold_min);
+      if (!renderer)
+        return false;
+      renderer_ = renderer.Pass();
+    } else {
+      scoped_ptr<SoftwareRenderer> renderer = SoftwareRenderer::Create(
+          this, &settings, output_surface.get(), resource_provider.get());
+      if (!renderer)
+        return false;
+      renderer_ = renderer.Pass();
+    }
+
+    output_surface_ = output_surface.Pass();
+    resource_provider_ = resource_provider.Pass();
+    child_id_ = resource_provider_->CreateChild(
+        base::Bind(&Display::ReturnResources, base::Unretained(this)));
+  }
+
   // TODO(jamesr): Use the surface aggregator instead.
   scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
   CompositorFrame* current_frame = current_surface_->GetEligibleFrame();
   frame_data->resource_list =
       current_frame->delegated_frame_data->resource_list;
   RenderPass::CopyAll(current_frame->delegated_frame_data->render_pass_list,
                       &frame_data->render_pass_list);
 
-  if (!layer_tree_host_) {
-    // TODO(jbauman): Switch to use ResourceProvider and GLRenderer directly,
-    // as using LayerTreeHost from here is a layering violation.
-    LayerTreeSettings settings;
-    layer_tree_host_ = LayerTreeHost::CreateSingleThreaded(
-        this, this, bitmap_manager_, settings);
-    resource_collection_ = new DelegatedFrameResourceCollection;
-    resource_collection_->SetClient(this);
-    layer_tree_host_->SetLayerTreeHostClientReady();
+  if (frame_data->render_pass_list.empty())
+    return false;
+
+  const ResourceProvider::ResourceIdMap& resource_map =
+      resource_provider_->GetChildToParentMap(child_id_);
+  resource_provider_->ReceiveFromChild(child_id_, frame_data->resource_list);

[jamesr, 2014/06/09 02:39:27]

i've got another patch in the queue that does the resource mgmt

+
+  bool invalid_frame = false;
+  ResourceProvider::ResourceIdArray resources_in_frame;
+  DrawQuad::ResourceIteratorCallback remap_resources_to_parent_callback =
+      base::Bind(&ResourceRemapHelper,
+                 &invalid_frame,
+                 resource_map,
+                 &resources_in_frame);
+  for (size_t i = 0; i < frame_data->render_pass_list.size(); ++i) {
+    RenderPass* pass = frame_data->render_pass_list[i];
+    for (size_t j = 0; j < pass->quad_list.size(); ++j) {
+      DrawQuad* quad = pass->quad_list[j];
+      quad->IterateResources(remap_resources_to_parent_callback);
+    }
   }
-  if (!delegated_frame_provider_ ||
-      delegated_frame_provider_->frame_size() !=
-          frame_data->render_pass_list.back()->output_rect.size()) {
-    delegated_frame_provider_ =
-        new DelegatedFrameProvider(resource_collection_, frame_data.Pass());
-    delegated_layer_ =
-        DelegatedRendererLayer::Create(delegated_frame_provider_);
 
-    layer_tree_host_->SetRootLayer(delegated_layer_);
-    delegated_layer_->SetDisplaySize(current_surface_->size());
-    delegated_layer_->SetBounds(current_surface_->size());
-    delegated_layer_->SetContentsOpaque(true);
-    delegated_layer_->SetIsDrawable(true);
-  } else {
-    delegated_frame_provider_->SetFrameData(frame_data.Pass());
-  }
-  layer_tree_host_->SetViewportSize(current_surface_->size());
+  if (invalid_frame)
+    return false;
+  resource_provider_->DeclareUsedResourcesFromChild(child_id_,
+                                                    resources_in_frame);
 
+  float device_scale_factor = 1.0f;
+  gfx::Rect device_viewport_rect = gfx::Rect(current_surface_->size());
+  gfx::Rect device_clip_rect = device_viewport_rect;
+  bool disable_picture_quad_image_filtering = false;
+
+  renderer_->DrawFrame(&frame_data->render_pass_list,
+                       device_scale_factor,
+                       device_viewport_rect,
+                       device_clip_rect,
+                       disable_picture_quad_image_filtering);
+  CompositorFrameMetadata metadata;
+  renderer_->SwapBuffers(metadata);
   return true;
 }
 
-scoped_ptr<OutputSurface> Display::CreateOutputSurface(bool fallback) {
-  return client_->CreateOutputSurface();
+void Display::DeferredInitialize() {

[jamesr, 2014/06/09 02:39:27]

could these all be inline? the clang checker should allow empty inline virtuals

+}
+void Display::ReleaseGL() {
+}
+void Display::CommitVSyncParameters(base::TimeTicks timebase,
+                                    base::TimeDelta interval) {
+}
+void Display::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
+}
+void Display::BeginFrame(const BeginFrameArgs& args) {
+}
+void Display::DidSwapBuffers() {
+}
+void Display::DidSwapBuffersComplete() {
+}
+void Display::ReclaimResources(const CompositorFrameAck* ack) {
+}
+void Display::DidLoseOutputSurface() {
+}
+void Display::SetExternalDrawConstraints(const gfx::Transform& transform,
+                                         const gfx::Rect& viewport,
+                                         const gfx::Rect& clip,
+                                         bool valid_for_tile_management) {
+}
+void Display::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
+}
+void Display::SetTreeActivationCallback(const base::Closure& callback) {
 }
 
-void Display::ScheduleComposite() {
-  if (scheduled_draw_)
-    return;
-
-  scheduled_draw_ = true;
-
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&Display::DoComposite, schedule_draw_factory_.GetWeakPtr()));
-}
-
-void Display::ScheduleAnimation() {
-  ScheduleComposite();
-}
-
-void Display::DoComposite() {
-  scheduled_draw_ = false;
-  layer_tree_host_->Composite(gfx::FrameTime::Now());
+void Display::SetFullRootLayerDamage() {
 }
 
 int Display::CurrentSurfaceID() {
   return current_surface_ ? current_surface_->surface_id() : 0;
 }
 
 void Display::ReturnResources(const ReturnedResourceArray& resources) {
-  // We never generate any resources, so we should never have any returned.
-  DCHECK(resources.empty());
 }
 
 }  // namespace cc
 
 #endif  // CC_SURFACES_DISPLAY_H_