cc: Add image decode queue functionality to image manager.

cc/trees/layer_tree_host_impl_unittest.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_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 181 matching lines @@
 
   virtual bool CreateHostImplWithTaskRunnerProvider(
       const LayerTreeSettings& settings,
       std::unique_ptr<CompositorFrameSink> compositor_frame_sink,
       TaskRunnerProvider* task_runner_provider) {
     if (host_impl_)
       host_impl_->ReleaseCompositorFrameSink();
     host_impl_ = LayerTreeHostImpl::Create(
         settings, this, task_runner_provider, &stats_instrumentation_,
         &task_graph_runner_,
-        AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0);
+        AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0, nullptr);
     compositor_frame_sink_ = std::move(compositor_frame_sink);
     host_impl_->SetVisible(true);
     bool init = host_impl_->InitializeRenderer(compositor_frame_sink_.get());
     host_impl_->SetViewportSize(gfx::Size(10, 10));
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     // Set the BeginFrameArgs so that methods which use it are able to.
     host_impl_->WillBeginImplFrame(CreateBeginFrameArgsForTesting(
         BEGINFRAME_FROM_HERE, 0, 1,
         base::TimeTicks() + base::TimeDelta::FromMilliseconds(1)));
     host_impl_->DidFinishImplFrame();
@@ skipping 2489 matching lines @@
       LayerTreeHostImplClient* client,
       TaskRunnerProvider* task_runner_provider,
       TaskGraphRunner* task_graph_runner,
       RenderingStatsInstrumentation* rendering_stats_instrumentation)
       : LayerTreeHostImpl(settings,
                           client,
                           task_runner_provider,
                           rendering_stats_instrumentation,
                           task_graph_runner,
                           AnimationHost::CreateForTesting(ThreadInstance::IMPL),
-                          0) {}
+                          0,
+                          nullptr) {}
 
   BeginFrameArgs CurrentBeginFrameArgs() const override {
     return CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 1,
                                           fake_current_physical_time_);
   }
 
   void SetCurrentPhysicalTimeTicksForTest(base::TimeTicks fake_now) {
     fake_current_physical_time_ = fake_now;
   }
 
@@ skipping 4849 matching lines @@
       compositor_frame_sink.get();
 
   // This test creates its own LayerTreeHostImpl, so
   // that we can force partial swap enabled.
   LayerTreeSettings settings = DefaultSettings();
   settings.renderer_settings.partial_swap_enabled = true;
   std::unique_ptr<LayerTreeHostImpl> layer_tree_host_impl =
       LayerTreeHostImpl::Create(
           settings, this, &task_runner_provider_, &stats_instrumentation_,
           &task_graph_runner_,
-          AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0);
+          AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0, nullptr);
   layer_tree_host_impl->SetVisible(true);
   layer_tree_host_impl->InitializeRenderer(compositor_frame_sink.get());
   layer_tree_host_impl->WillBeginImplFrame(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2));
   layer_tree_host_impl->SetViewportSize(gfx::Size(500, 500));
 
   std::unique_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 1);
   root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> child =
@@ skipping 108 matching lines @@
     bool partial_swap,
     LayerTreeHostImplClient* client,
     TaskRunnerProvider* task_runner_provider,
     TaskGraphRunner* task_graph_runner,
     RenderingStatsInstrumentation* stats_instrumentation,
     CompositorFrameSink* compositor_frame_sink) {
   settings.renderer_settings.partial_swap_enabled = partial_swap;
   std::unique_ptr<LayerTreeHostImpl> my_host_impl = LayerTreeHostImpl::Create(
       settings, client, task_runner_provider, stats_instrumentation,
       task_graph_runner, AnimationHost::CreateForTesting(ThreadInstance::IMPL),
-      0);
+      0, nullptr);
   my_host_impl->SetVisible(true);
   my_host_impl->InitializeRenderer(compositor_frame_sink);
   my_host_impl->WillBeginImplFrame(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2));
   my_host_impl->SetViewportSize(gfx::Size(100, 100));
 
   /*
     Layers are created as follows:
 
     +--------------------+
@@ skipping 447 matching lines @@
   EXPECT_NE(kSoftwareTileCutoff, kNothingTileCutoff);
 
   LayerTreeSettings settings = DefaultSettings();
   settings.gpu_memory_policy =
       ManagedMemoryPolicy(kGpuByteLimit, kGpuCutoff, kGpuResourceLimit);
   settings.software_memory_policy = ManagedMemoryPolicy(
       kSoftwareByteLimit, kSoftwareCutoff, kSoftwareResourceLimit);
   host_impl_ = LayerTreeHostImpl::Create(
       settings, this, &task_runner_provider_, &stats_instrumentation_,
       &task_graph_runner_,
-      AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0);
+      AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0, nullptr);
 
   // Gpu compositing.
   compositor_frame_sink_ =
       FakeCompositorFrameSink::Create3d(TestWebGraphicsContext3D::Create());
   host_impl_->SetVisible(true);
   host_impl_->InitializeRenderer(compositor_frame_sink_.get());
   {
     const auto& state = host_impl_->global_tile_state();
     EXPECT_EQ(kGpuByteLimit, state.hard_memory_limit_in_bytes);
     EXPECT_EQ(kGpuResourceLimit, state.num_resources_limit);
@@ skipping 3408 matching lines @@
 TEST_F(LayerTreeHostImplTest, RecomputeGpuRasterOnCompositorFrameSinkChange) {
   host_impl_->ReleaseCompositorFrameSink();
   host_impl_ = nullptr;
 
   LayerTreeSettings settings = DefaultSettings();
   settings.gpu_rasterization_forced = true;
 
   host_impl_ = LayerTreeHostImpl::Create(
       settings, this, &task_runner_provider_, &stats_instrumentation_,
       &task_graph_runner_,
-      AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0);
+      AnimationHost::CreateForTesting(ThreadInstance::IMPL), 0, nullptr);
   host_impl_->SetVisible(true);
 
   // InitializeRenderer with a gpu-raster enabled output surface.
   auto gpu_raster_compositor_frame_sink =
       FakeCompositorFrameSink::Create3d(TestWebGraphicsContext3D::Create());
   host_impl_->InitializeRenderer(gpu_raster_compositor_frame_sink.get());
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
 
   // Re-initialize with a software output surface.
   compositor_frame_sink_ = FakeCompositorFrameSink::CreateSoftware();
@@ skipping 121 matching lines @@
   EXPECT_FALSE(scrollbar_2_animation_controller->mouse_is_over_scrollbar());
   host_impl_->MouseMoveAt(gfx::Point(10, 150));
   EXPECT_TRUE(scrollbar_1_animation_controller->mouse_is_near_scrollbar());
   EXPECT_TRUE(scrollbar_1_animation_controller->mouse_is_over_scrollbar());
   EXPECT_FALSE(scrollbar_2_animation_controller->mouse_is_near_scrollbar());
   EXPECT_FALSE(scrollbar_2_animation_controller->mouse_is_over_scrollbar());
 }
 
 }  // namespace
 }  // namespace cc