cc: Move UI Resource management out of LayerTreeHost.

cc/trees/layer_tree_host.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 30 matching lines @@
 #include "cc/input/page_scale_animation.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/layer_proto_converter.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/layer_tree.pb.h"
 #include "cc/proto/layer_tree_host.pb.h"
-#include "cc/resources/ui_resource_request.h"
+#include "cc/resources/ui_resource_manager.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree_builder.h"
 #include "cc/trees/proxy_main.h"
 #include "cc/trees/remote_channel_impl.h"
 #include "cc/trees/single_thread_proxy.h"
@@ skipping 74 matching lines @@
   DCHECK(impl_task_runner.get());
   DCHECK(params->settings);
   std::unique_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(params, CompositorMode::THREADED));
   layer_tree_host->InitializeThreaded(
       params->main_task_runner, impl_task_runner,
       std::move(params->external_begin_frame_source));
   return std::move(layer_tree_host);
 }
 
-std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateSingleThreaded(
+std::unique_ptr<LayerTreeHostInterface> LayerTreeHost::CreateSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
     InitParams* params) {
   DCHECK(params->settings);
   std::unique_ptr<LayerTreeHost> layer_tree_host(
       new LayerTreeHost(params, CompositorMode::SINGLE_THREADED));
   layer_tree_host->InitializeSingleThreaded(
       single_thread_client, params->main_task_runner,
       std::move(params->external_begin_frame_source));
-  return layer_tree_host;
+  return std::move(layer_tree_host);
 }
 
 std::unique_ptr<LayerTreeHostInterface> LayerTreeHost::CreateRemoteServer(
     RemoteProtoChannel* remote_proto_channel,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(params->settings);
   DCHECK(remote_proto_channel);
   TRACE_EVENT0("cc.remote", "LayerTreeHost::CreateRemoteServer");
 
@@ skipping 37 matching lines @@
           params,
           mode,
           base::MakeUnique<LayerTree>(std::move(params->animation_host),
                                       this)) {}
 
 LayerTreeHost::LayerTreeHost(InitParams* params,
                              CompositorMode mode,
                              std::unique_ptr<LayerTree> layer_tree)
     : micro_benchmark_controller_(this),
       layer_tree_(std::move(layer_tree)),
-      next_ui_resource_id_(1),
       compositor_mode_(mode),
+      ui_resource_manager_(base::MakeUnique<UIResourceManager>()),
       client_(params->client),
       source_frame_number_(0),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       settings_(*params->settings),
       debug_state_(settings_.initial_debug_state),
       visible_(false),
       has_gpu_rasterization_trigger_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       gpu_rasterization_histogram_recorded_(false),
       did_complete_scale_animation_(false),
@@ skipping 94 matching lines @@
   client_picture_cache_ =
       image_serialization_processor_->CreateClientPictureCache();
 }
 
 void LayerTreeHost::SetTaskRunnerProviderForTesting(
     std::unique_ptr<TaskRunnerProvider> task_runner_provider) {
   DCHECK(!task_runner_provider_);
   task_runner_provider_ = std::move(task_runner_provider);
 }
 
+void LayerTreeHost::SetUIResourceManagerForTesting(
+    std::unique_ptr<UIResourceManager> ui_resource_manager) {
+  ui_resource_manager_ = std::move(ui_resource_manager);
+}
+
 void LayerTreeHost::InitializeProxy(
     std::unique_ptr<Proxy> proxy,
     std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
   DCHECK(task_runner_provider_);
 
   proxy_ = std::move(proxy);
   proxy_->Start(std::move(external_begin_frame_source));
 
   layer_tree_->animation_host()->SetSupportsScrollAnimations(
@@ skipping 28 matching lines @@
 }
 
 LayerTree* LayerTreeHost::GetLayerTree() {
   return layer_tree_.get();
 }
 
 const LayerTree* LayerTreeHost::GetLayerTree() const {
   return layer_tree_.get();
 }
 
+UIResourceManager* LayerTreeHost::GetUIResourceManager() const {
+  return ui_resource_manager_.get();
+}
+
 TaskRunnerProvider* LayerTreeHost::GetTaskRunnerProvider() const {
   return task_runner_provider_.get();
 }
 
 const LayerTreeSettings& LayerTreeHost::GetSettings() const {
   return settings_;
 }
 
 void LayerTreeHost::WillBeginMainFrame() {
   devtools_instrumentation::WillBeginMainThreadFrame(GetId(),
@@ skipping 66 matching lines @@
   RecordGpuRasterizationHistogram();
 
   host_impl->SetViewportSize(layer_tree_->device_viewport_size());
   // TODO(senorblanco): Move this to LayerTree::PushPropertiesTo so that it
   // happens before GPU rasterization properties are set, since those trigger an
   // update of GPU rasterization status, which depends on the device scale
   // factor. (crbug.com/535700)
   sync_tree->SetDeviceScaleFactor(layer_tree_->device_scale_factor());
   host_impl->SetDebugState(debug_state_);
 
-  if (!ui_resource_request_queue_.empty()) {
-    sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
-    ui_resource_request_queue_.clear();
+  std::vector<UIResourceRequest> ui_resource_request_queue =
+      ui_resource_manager_->TakeUIResourcesRequests();
+
+  if (!ui_resource_request_queue.empty()) {
+    sync_tree->set_ui_resource_request_queue(ui_resource_request_queue);

[danakj, 2016/09/08 20:57:35]

Why not just move the queue here? In fact why isnt this then just

sync_tree->set_ui_resource_request_queue(ui_resource_manager_->TakeUIResourcesRequests());
? And change it to receive by value and move, then we're not copying vectors
anywhere.

[Khushal, 2016/09/08 22:05:24]

Much cooler. Done.

+    ui_resource_request_queue.clear();
   }
 
   {
     TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
 
     TreeSynchronizer::PushLayerProperties(layer_tree_.get(), sync_tree);
 
     // This must happen after synchronizing property trees and after push
     // properties, which updates property tree indices, but before animation
     // host pushes properties as animation host push properties can change
@@ skipping 429 matching lines @@
   AnimationHost* animation_host = layer_tree_->animation_host();
   std::unique_ptr<AnimationEvents> events = animation_host->CreateEvents();
 
   if (animation_host->AnimateLayers(monotonic_time))
     animation_host->UpdateAnimationState(true, events.get());
 
   if (!events->events_.empty())
     layer_tree_->property_trees()->needs_rebuild = true;
 }
 
-UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
-  DCHECK(client);
-
-  UIResourceId next_id = next_ui_resource_id_++;
-  DCHECK(ui_resource_client_map_.find(next_id) ==
-         ui_resource_client_map_.end());
-
-  bool resource_lost = false;
-  UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, next_id,
-                            client->GetBitmap(next_id, resource_lost));
-  ui_resource_request_queue_.push_back(request);
-
-  UIResourceClientData data;
-  data.client = client;
-  data.size = request.GetBitmap().GetSize();
-
-  ui_resource_client_map_[request.GetId()] = data;
-  return request.GetId();
-}
-
-// Deletes a UI resource.  May safely be called more than once.
-void LayerTreeHost::DeleteUIResource(UIResourceId uid) {
-  UIResourceClientMap::iterator iter = ui_resource_client_map_.find(uid);
-  if (iter == ui_resource_client_map_.end())
-    return;
-
-  UIResourceRequest request(UIResourceRequest::UI_RESOURCE_DELETE, uid);
-  ui_resource_request_queue_.push_back(request);
-  ui_resource_client_map_.erase(iter);
-}
-
-void LayerTreeHost::RecreateUIResources() {
-  for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
-       iter != ui_resource_client_map_.end();
-       ++iter) {
-    UIResourceId uid = iter->first;
-    const UIResourceClientData& data = iter->second;
-    bool resource_lost = true;
-    auto it = std::find_if(ui_resource_request_queue_.begin(),
-                           ui_resource_request_queue_.end(),
-                           [uid](const UIResourceRequest& request) {
-                             return request.GetId() == uid;
-                           });
-    if (it == ui_resource_request_queue_.end()) {
-      UIResourceRequest request(UIResourceRequest::UI_RESOURCE_CREATE, uid,
-                                data.client->GetBitmap(uid, resource_lost));
-      ui_resource_request_queue_.push_back(request);
-    }
-  }
-}
-
-// Returns the size of a resource given its id.
-gfx::Size LayerTreeHost::GetUIResourceSize(UIResourceId uid) const {
-  UIResourceClientMap::const_iterator iter = ui_resource_client_map_.find(uid);
-  if (iter == ui_resource_client_map_.end())
-    return gfx::Size();
-
-  const UIResourceClientData& data = iter->second;
-  return data.size;
-}
-
 int LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     std::unique_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
   return micro_benchmark_controller_.ScheduleRun(benchmark_name,
                                                  std::move(value), callback);
 }
 
 bool LayerTreeHost::SendMessageToMicroBenchmark(
     int id,
@@ skipping 156 matching lines @@
   content_is_suitable_for_gpu_rasterization_ =
       proto.content_is_suitable_for_gpu_rasterization();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
 
   surface_client_id_ = proto.surface_client_id();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
 }  // namespace cc