OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/trees/layer_tree_host_impl.h" | 5 #include "cc/trees/layer_tree_host_impl.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <limits> | 8 #include <limits> |
9 | 9 |
10 #include "base/basictypes.h" | 10 #include "base/basictypes.h" |
(...skipping 1947 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1958 base::SingleThreadTaskRunner* task_runner = | 1958 base::SingleThreadTaskRunner* task_runner = |
1959 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner() | 1959 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner() |
1960 : proxy_->MainThreadTaskRunner(); | 1960 : proxy_->MainThreadTaskRunner(); |
1961 DCHECK(task_runner); | 1961 DCHECK(task_runner); |
1962 size_t scheduled_raster_task_limit = | 1962 size_t scheduled_raster_task_limit = |
1963 IsSynchronousSingleThreaded() ? std::numeric_limits<size_t>::max() | 1963 IsSynchronousSingleThreaded() ? std::numeric_limits<size_t>::max() |
1964 : settings_.scheduled_raster_task_limit; | 1964 : settings_.scheduled_raster_task_limit; |
1965 tile_manager_ = TileManager::Create( | 1965 tile_manager_ = TileManager::Create( |
1966 this, task_runner, resource_pool_.get(), | 1966 this, task_runner, resource_pool_.get(), |
1967 tile_task_worker_pool_->AsTileTaskRunner(), | 1967 tile_task_worker_pool_->AsTileTaskRunner(), |
| 1968 settings_.renderer_settings.tile_compression_threshold, |
1968 rendering_stats_instrumentation_, scheduled_raster_task_limit); | 1969 rendering_stats_instrumentation_, scheduled_raster_task_limit); |
1969 | 1970 |
1970 UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy()); | 1971 UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy()); |
1971 } | 1972 } |
1972 | 1973 |
1973 void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool( | 1974 void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool( |
1974 scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool, | 1975 scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool, |
1975 scoped_ptr<ResourcePool>* resource_pool, | 1976 scoped_ptr<ResourcePool>* resource_pool, |
1976 scoped_ptr<ResourcePool>* staging_resource_pool) { | 1977 scoped_ptr<ResourcePool>* staging_resource_pool) { |
1977 base::SingleThreadTaskRunner* task_runner = | 1978 base::SingleThreadTaskRunner* task_runner = |
1978 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner() | 1979 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner() |
1979 : proxy_->MainThreadTaskRunner(); | 1980 : proxy_->MainThreadTaskRunner(); |
1980 DCHECK(task_runner); | 1981 DCHECK(task_runner); |
1981 | 1982 |
1982 ContextProvider* context_provider = output_surface_->context_provider(); | 1983 ContextProvider* context_provider = output_surface_->context_provider(); |
1983 if (!context_provider) { | 1984 if (!context_provider) { |
1984 *resource_pool = | 1985 *resource_pool = |
1985 ResourcePool::Create(resource_provider_.get(), | 1986 ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D, false); |
1986 GL_TEXTURE_2D, | |
1987 resource_provider_->best_texture_format()); | |
1988 | 1987 |
1989 *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create( | 1988 *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create( |
1990 task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), | 1989 task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), |
1991 resource_provider_.get()); | 1990 resource_provider_.get()); |
1992 return; | 1991 return; |
1993 } | 1992 } |
1994 | 1993 |
1995 if (use_gpu_rasterization_) { | 1994 if (use_gpu_rasterization_) { |
1996 *resource_pool = | 1995 *resource_pool = |
1997 ResourcePool::Create(resource_provider_.get(), | 1996 ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D, false); |
1998 GL_TEXTURE_2D, | |
1999 resource_provider_->best_texture_format()); | |
2000 | 1997 |
2001 *tile_task_worker_pool = GpuTileTaskWorkerPool::Create( | 1998 *tile_task_worker_pool = GpuTileTaskWorkerPool::Create( |
2002 task_runner, context_provider, resource_provider_.get(), | 1999 task_runner, context_provider, resource_provider_.get(), |
2003 settings_.use_distance_field_text); | 2000 settings_.use_distance_field_text); |
2004 return; | 2001 return; |
2005 } | 2002 } |
2006 | 2003 |
2007 if (GetRendererCapabilities().using_image) { | 2004 if (GetRendererCapabilities().using_image) { |
2008 unsigned image_target = settings_.use_image_texture_target; | 2005 unsigned image_target = settings_.use_image_texture_target; |
2009 DCHECK_IMPLIES( | 2006 DCHECK_IMPLIES( |
2010 image_target == GL_TEXTURE_RECTANGLE_ARB, | 2007 image_target == GL_TEXTURE_RECTANGLE_ARB, |
2011 context_provider->ContextCapabilities().gpu.texture_rectangle); | 2008 context_provider->ContextCapabilities().gpu.texture_rectangle); |
2012 DCHECK_IMPLIES( | 2009 DCHECK_IMPLIES( |
2013 image_target == GL_TEXTURE_EXTERNAL_OES, | 2010 image_target == GL_TEXTURE_EXTERNAL_OES, |
2014 context_provider->ContextCapabilities().gpu.egl_image_external); | 2011 context_provider->ContextCapabilities().gpu.egl_image_external); |
2015 | 2012 |
2016 if (settings_.use_zero_copy || IsSynchronousSingleThreaded()) { | 2013 if (settings_.use_zero_copy || IsSynchronousSingleThreaded()) { |
2017 *resource_pool = | 2014 *resource_pool = |
2018 ResourcePool::Create(resource_provider_.get(), image_target, | 2015 ResourcePool::Create(resource_provider_.get(), image_target, false); |
2019 resource_provider_->best_texture_format()); | |
2020 | 2016 |
2021 TaskGraphRunner* task_graph_runner; | 2017 TaskGraphRunner* task_graph_runner; |
2022 if (IsSynchronousSingleThreaded()) { | 2018 if (IsSynchronousSingleThreaded()) { |
2023 DCHECK(!single_thread_synchronous_task_graph_runner_); | 2019 DCHECK(!single_thread_synchronous_task_graph_runner_); |
2024 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner); | 2020 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner); |
2025 task_graph_runner = single_thread_synchronous_task_graph_runner_.get(); | 2021 task_graph_runner = single_thread_synchronous_task_graph_runner_.get(); |
2026 } else { | 2022 } else { |
2027 task_graph_runner = TileTaskWorkerPool::GetTaskGraphRunner(); | 2023 task_graph_runner = TileTaskWorkerPool::GetTaskGraphRunner(); |
2028 } | 2024 } |
2029 | 2025 |
2030 *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create( | 2026 *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create( |
2031 task_runner, task_graph_runner, resource_provider_.get()); | 2027 task_runner, task_graph_runner, resource_provider_.get()); |
2032 return; | 2028 return; |
2033 } | 2029 } |
2034 | 2030 |
2035 if (settings_.use_one_copy) { | 2031 if (settings_.use_one_copy) { |
2036 // We need to create a staging resource pool when using copy rasterizer. | 2032 // We need to create a staging resource pool when using copy rasterizer. |
2037 *staging_resource_pool = | 2033 *staging_resource_pool = |
2038 ResourcePool::Create(resource_provider_.get(), image_target, | 2034 ResourcePool::Create(resource_provider_.get(), image_target, true); |
2039 resource_provider_->best_texture_format()); | |
2040 *resource_pool = | 2035 *resource_pool = |
2041 ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D, | 2036 ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D, true); |
2042 resource_provider_->best_texture_format()); | |
2043 | 2037 |
2044 *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create( | 2038 *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create( |
2045 task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), | 2039 task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), |
2046 context_provider, resource_provider_.get(), | 2040 context_provider, resource_provider_.get(), |
2047 staging_resource_pool_.get()); | 2041 staging_resource_pool_.get()); |
2048 return; | 2042 return; |
2049 } | 2043 } |
2050 } | 2044 } |
2051 | 2045 |
2052 *resource_pool = ResourcePool::Create( | 2046 *resource_pool = |
2053 resource_provider_.get(), GL_TEXTURE_2D, | 2047 ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D, true); |
2054 resource_provider_->memory_efficient_texture_format()); | |
2055 | 2048 |
2056 *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create( | 2049 *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create( |
2057 task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), context_provider, | 2050 task_runner, TileTaskWorkerPool::GetTaskGraphRunner(), context_provider, |
2058 resource_provider_.get(), | 2051 resource_provider_.get(), |
2059 GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(), | 2052 GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(), |
2060 settings_.renderer_settings.refresh_rate)); | 2053 settings_.renderer_settings.refresh_rate)); |
2061 } | 2054 } |
2062 | 2055 |
2063 void LayerTreeHostImpl::DestroyTileManager() { | 2056 void LayerTreeHostImpl::DestroyTileManager() { |
2064 tile_manager_ = nullptr; | 2057 tile_manager_ = nullptr; |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2099 | 2092 |
2100 if (!output_surface->BindToClient(this)) | 2093 if (!output_surface->BindToClient(this)) |
2101 return false; | 2094 return false; |
2102 | 2095 |
2103 output_surface_ = output_surface.Pass(); | 2096 output_surface_ = output_surface.Pass(); |
2104 resource_provider_ = ResourceProvider::Create( | 2097 resource_provider_ = ResourceProvider::Create( |
2105 output_surface_.get(), shared_bitmap_manager_, gpu_memory_buffer_manager_, | 2098 output_surface_.get(), shared_bitmap_manager_, gpu_memory_buffer_manager_, |
2106 proxy_->blocking_main_thread_task_runner(), | 2099 proxy_->blocking_main_thread_task_runner(), |
2107 settings_.renderer_settings.highp_threshold_min, | 2100 settings_.renderer_settings.highp_threshold_min, |
2108 settings_.renderer_settings.use_rgba_4444_textures, | 2101 settings_.renderer_settings.use_rgba_4444_textures, |
| 2102 settings_.renderer_settings.enable_tile_compression, |
2109 settings_.renderer_settings.texture_id_allocation_chunk_size); | 2103 settings_.renderer_settings.texture_id_allocation_chunk_size); |
2110 | 2104 |
| 2105 resource_provider_->set_preferred_tile_compression_method( |
| 2106 settings_.renderer_settings.tile_compression_method); |
| 2107 |
2111 if (output_surface_->capabilities().deferred_gl_initialization) | 2108 if (output_surface_->capabilities().deferred_gl_initialization) |
2112 EnforceZeroBudget(true); | 2109 EnforceZeroBudget(true); |
2113 | 2110 |
2114 CreateAndSetRenderer(); | 2111 CreateAndSetRenderer(); |
2115 | 2112 |
2116 if (settings_.impl_side_painting) | 2113 if (settings_.impl_side_painting) |
2117 CreateAndSetTileManager(); | 2114 CreateAndSetTileManager(); |
2118 | 2115 |
2119 // Initialize vsync parameters to sane values. | 2116 // Initialize vsync parameters to sane values. |
2120 const base::TimeDelta display_refresh_interval = | 2117 const base::TimeDelta display_refresh_interval = |
(...skipping 1359 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3480 } | 3477 } |
3481 | 3478 |
3482 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { | 3479 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { |
3483 std::vector<PictureLayerImpl*>::iterator it = | 3480 std::vector<PictureLayerImpl*>::iterator it = |
3484 std::find(picture_layers_.begin(), picture_layers_.end(), layer); | 3481 std::find(picture_layers_.begin(), picture_layers_.end(), layer); |
3485 DCHECK(it != picture_layers_.end()); | 3482 DCHECK(it != picture_layers_.end()); |
3486 picture_layers_.erase(it); | 3483 picture_layers_.erase(it); |
3487 } | 3484 } |
3488 | 3485 |
3489 } // namespace cc | 3486 } // namespace cc |
OLD | NEW |