Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(176)

Side by Side Diff: cc/trees/layer_tree_host_impl.cc

Issue 699073004: content: Add command line flag for native GPU memory buffers. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@gpu-memory-buffer-impl-unittests
Patch Set: fix unit test failures on macosx Created 6 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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 133 matching lines...) Expand 10 before | Expand all | Expand 10 after
144 // that time interval, and then uploads should have a chance to be processed. 144 // that time interval, and then uploads should have a chance to be processed.
145 size_t ms_per_frame = std::floor(1000.0 / refresh_rate); 145 size_t ms_per_frame = std::floor(1000.0 / refresh_rate);
146 size_t max_transfer_buffer_usage_bytes = 146 size_t max_transfer_buffer_usage_bytes =
147 ms_per_frame * kMaxBytesUploadedPerMs; 147 ms_per_frame * kMaxBytesUploadedPerMs;
148 148
149 // The context may request a lower limit based on the device capabilities. 149 // The context may request a lower limit based on the device capabilities.
150 return std::min(context_capabilities.max_transfer_buffer_usage_bytes, 150 return std::min(context_capabilities.max_transfer_buffer_usage_bytes,
151 max_transfer_buffer_usage_bytes); 151 max_transfer_buffer_usage_bytes);
152 } 152 }
153 153
154 unsigned GetMapImageTextureTarget(
155 const ContextProvider::Capabilities& context_capabilities) {
156 // TODO(reveman): This should be a setting passed to the compositor instead
157 // of hard-coded here. The target that need to be used depends on our choice
158 // of GpuMemoryBuffer type. Note: SURFACE_TEXTURE needs EXTERNAL_OES,
159 // IO_SURFACE needs RECTANGLE_ARB. crbug.com/431059
160 #if defined(OS_ANDROID)
161 if (context_capabilities.gpu.egl_image_external)
162 return GL_TEXTURE_EXTERNAL_OES;
163 #endif
164 if (context_capabilities.gpu.texture_rectangle)
165 return GL_TEXTURE_RECTANGLE_ARB;
166
167 return GL_TEXTURE_2D;
168 }
169
170 size_t GetMaxStagingResourceCount() { 154 size_t GetMaxStagingResourceCount() {
171 // Upper bound for number of staging resource to allow. 155 // Upper bound for number of staging resource to allow.
172 return 32; 156 return 32;
173 } 157 }
174 158
175 } // namespace 159 } // namespace
176 160
177 LayerTreeHostImpl::FrameData::FrameData() : has_no_damage(false) { 161 LayerTreeHostImpl::FrameData::FrameData() : has_no_damage(false) {
178 } 162 }
179 163
(...skipping 1818 matching lines...) Expand 10 before | Expand all | Expand 10 after
1998 void LayerTreeHostImpl::CreateResourceAndRasterWorkerPool( 1982 void LayerTreeHostImpl::CreateResourceAndRasterWorkerPool(
1999 scoped_ptr<RasterWorkerPool>* raster_worker_pool, 1983 scoped_ptr<RasterWorkerPool>* raster_worker_pool,
2000 scoped_ptr<ResourcePool>* resource_pool, 1984 scoped_ptr<ResourcePool>* resource_pool,
2001 scoped_ptr<ResourcePool>* staging_resource_pool) { 1985 scoped_ptr<ResourcePool>* staging_resource_pool) {
2002 base::SingleThreadTaskRunner* task_runner = 1986 base::SingleThreadTaskRunner* task_runner =
2003 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner() 1987 proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
2004 : proxy_->MainThreadTaskRunner(); 1988 : proxy_->MainThreadTaskRunner();
2005 DCHECK(task_runner); 1989 DCHECK(task_runner);
2006 1990
2007 ContextProvider* context_provider = output_surface_->context_provider(); 1991 ContextProvider* context_provider = output_surface_->context_provider();
2008 bool should_use_zero_copy_rasterizer =
2009 settings_.use_zero_copy || IsSynchronousSingleThreaded();
2010
2011 if (!context_provider) { 1992 if (!context_provider) {
2012 *resource_pool = 1993 *resource_pool =
2013 ResourcePool::Create(resource_provider_.get(), 1994 ResourcePool::Create(resource_provider_.get(),
2014 GL_TEXTURE_2D, 1995 GL_TEXTURE_2D,
2015 resource_provider_->best_texture_format()); 1996 resource_provider_->best_texture_format());
2016 1997
2017 *raster_worker_pool = 1998 *raster_worker_pool =
2018 BitmapRasterWorkerPool::Create(task_runner, 1999 BitmapRasterWorkerPool::Create(task_runner,
2019 RasterWorkerPool::GetTaskGraphRunner(), 2000 RasterWorkerPool::GetTaskGraphRunner(),
2020 resource_provider_.get()); 2001 resource_provider_.get());
2021 } else if (use_gpu_rasterization_) { 2002 return;
2003 }
2004
2005 if (use_gpu_rasterization_) {
2022 *resource_pool = 2006 *resource_pool =
2023 ResourcePool::Create(resource_provider_.get(), 2007 ResourcePool::Create(resource_provider_.get(),
2024 GL_TEXTURE_2D, 2008 GL_TEXTURE_2D,
2025 resource_provider_->best_texture_format()); 2009 resource_provider_->best_texture_format());
2026 2010
2027 *raster_worker_pool = 2011 *raster_worker_pool =
2028 GpuRasterWorkerPool::Create(task_runner, 2012 GpuRasterWorkerPool::Create(task_runner,
2029 context_provider, 2013 context_provider,
2030 resource_provider_.get(), 2014 resource_provider_.get(),
2031 settings_.use_distance_field_text); 2015 settings_.use_distance_field_text);
2032 } else if (should_use_zero_copy_rasterizer && CanUseZeroCopyRasterizer()) { 2016 return;
2033 *resource_pool = ResourcePool::Create( 2017 }
2034 resource_provider_.get(),
2035 GetMapImageTextureTarget(context_provider->ContextCapabilities()),
2036 resource_provider_->best_texture_format());
2037 2018
2038 TaskGraphRunner* task_graph_runner; 2019 if (GetRendererCapabilities().using_image) {
2039 if (IsSynchronousSingleThreaded()) { 2020 unsigned image_target = GL_TEXTURE_2D;
2040 DCHECK(!single_thread_synchronous_task_graph_runner_); 2021 #if defined(OS_MACOSX)
2041 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner); 2022 // GL_TEXTURE_RECTANGLE_ARB target is required by IOSurface backed images.
2042 task_graph_runner = single_thread_synchronous_task_graph_runner_.get(); 2023 DCHECK(context_provider->ContextCapabilities().gpu.texture_rectangle);
2043 } else { 2024 image_target = GL_TEXTURE_RECTANGLE_ARB;
2044 task_graph_runner = RasterWorkerPool::GetTaskGraphRunner(); 2025 #endif
2026 if (settings_.use_image_external) {
2027 DCHECK(context_provider->ContextCapabilities().gpu.egl_image_external);
2028 image_target = GL_TEXTURE_EXTERNAL_OES;
2045 } 2029 }
2046 2030
2047 *raster_worker_pool = ZeroCopyRasterWorkerPool::Create( 2031 if (settings_.use_zero_copy || IsSynchronousSingleThreaded()) {
2048 task_runner, task_graph_runner, resource_provider_.get()); 2032 *resource_pool =
2049 } else if (settings_.use_one_copy && CanUseOneCopyRasterizer()) { 2033 ResourcePool::Create(resource_provider_.get(), image_target,
2050 // We need to create a staging resource pool when using copy rasterizer. 2034 resource_provider_->best_texture_format());
2051 *staging_resource_pool = ResourcePool::Create(
2052 resource_provider_.get(),
2053 GetMapImageTextureTarget(context_provider->ContextCapabilities()),
2054 resource_provider_->best_texture_format());
2055 *resource_pool =
2056 ResourcePool::Create(resource_provider_.get(),
2057 GL_TEXTURE_2D,
2058 resource_provider_->best_texture_format());
2059 2035
2060 *raster_worker_pool = 2036 TaskGraphRunner* task_graph_runner;
2061 OneCopyRasterWorkerPool::Create(task_runner, 2037 if (IsSynchronousSingleThreaded()) {
2062 RasterWorkerPool::GetTaskGraphRunner(), 2038 DCHECK(!single_thread_synchronous_task_graph_runner_);
2063 context_provider, 2039 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
2064 resource_provider_.get(), 2040 task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
2065 staging_resource_pool_.get()); 2041 } else {
2066 } else { 2042 task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
2067 *resource_pool = ResourcePool::Create( 2043 }
2068 resource_provider_.get(),
2069 GL_TEXTURE_2D,
2070 resource_provider_->memory_efficient_texture_format());
2071 2044
2072 *raster_worker_pool = PixelBufferRasterWorkerPool::Create( 2045 *raster_worker_pool = ZeroCopyRasterWorkerPool::Create(
2073 task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider, 2046 task_runner, task_graph_runner, resource_provider_.get());
2074 resource_provider_.get(), 2047 return;
2075 GetMaxTransferBufferUsageBytes( 2048 }
2076 context_provider->ContextCapabilities(), 2049
2077 settings_.renderer_settings.refresh_rate)); 2050 if (settings_.use_one_copy) {
2051 // We need to create a staging resource pool when using copy rasterizer.
2052 *staging_resource_pool =
2053 ResourcePool::Create(resource_provider_.get(), image_target,
2054 resource_provider_->best_texture_format());
2055 *resource_pool =
2056 ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D,
2057 resource_provider_->best_texture_format());
2058
2059 *raster_worker_pool = OneCopyRasterWorkerPool::Create(
2060 task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider,
2061 resource_provider_.get(), staging_resource_pool_.get());
2062 return;
2063 }
2078 } 2064 }
2065
2066 *resource_pool = ResourcePool::Create(
2067 resource_provider_.get(), GL_TEXTURE_2D,
2068 resource_provider_->memory_efficient_texture_format());
2069
2070 *raster_worker_pool = PixelBufferRasterWorkerPool::Create(
2071 task_runner, RasterWorkerPool::GetTaskGraphRunner(), context_provider,
2072 resource_provider_.get(),
2073 GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
2074 settings_.renderer_settings.refresh_rate));
2079 } 2075 }
2080 2076
2081 void LayerTreeHostImpl::DestroyTileManager() { 2077 void LayerTreeHostImpl::DestroyTileManager() {
2082 tile_manager_ = nullptr; 2078 tile_manager_ = nullptr;
2083 resource_pool_ = nullptr; 2079 resource_pool_ = nullptr;
2084 staging_resource_pool_ = nullptr; 2080 staging_resource_pool_ = nullptr;
2085 raster_worker_pool_ = nullptr; 2081 raster_worker_pool_ = nullptr;
2086 single_thread_synchronous_task_graph_runner_ = nullptr; 2082 single_thread_synchronous_task_graph_runner_ = nullptr;
2087 } 2083 }
2088 2084
2089 bool LayerTreeHostImpl::UsePendingTreeForSync() const { 2085 bool LayerTreeHostImpl::UsePendingTreeForSync() const {
2090 // In impl-side painting, synchronize to the pending tree so that it has 2086 // In impl-side painting, synchronize to the pending tree so that it has
2091 // time to raster before being displayed. 2087 // time to raster before being displayed.
2092 return settings_.impl_side_painting; 2088 return settings_.impl_side_painting;
2093 } 2089 }
2094 2090
2095 bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const { 2091 bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const {
2096 return !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler; 2092 return !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler;
2097 } 2093 }
2098 2094
2099 bool LayerTreeHostImpl::CanUseZeroCopyRasterizer() const {
2100 return GetRendererCapabilities().using_image;
2101 }
2102
2103 bool LayerTreeHostImpl::CanUseOneCopyRasterizer() const {
2104 return GetRendererCapabilities().using_image;
2105 }
2106
2107 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) { 2095 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
2108 SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget); 2096 SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
2109 } 2097 }
2110 2098
2111 bool LayerTreeHostImpl::InitializeRenderer( 2099 bool LayerTreeHostImpl::InitializeRenderer(
2112 scoped_ptr<OutputSurface> output_surface) { 2100 scoped_ptr<OutputSurface> output_surface) {
2113 TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer"); 2101 TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
2114 2102
2115 // Since we will create a new resource provider, we cannot continue to use 2103 // Since we will create a new resource provider, we cannot continue to use
2116 // the old resources (i.e. render_surfaces and texture IDs). Clear them 2104 // the old resources (i.e. render_surfaces and texture IDs). Clear them
(...skipping 1374 matching lines...) Expand 10 before | Expand all | Expand 10 after
3491 } 3479 }
3492 3480
3493 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { 3481 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
3494 std::vector<PictureLayerImpl*>::iterator it = 3482 std::vector<PictureLayerImpl*>::iterator it =
3495 std::find(picture_layers_.begin(), picture_layers_.end(), layer); 3483 std::find(picture_layers_.begin(), picture_layers_.end(), layer);
3496 DCHECK(it != picture_layers_.end()); 3484 DCHECK(it != picture_layers_.end());
3497 picture_layers_.erase(it); 3485 picture_layers_.erase(it);
3498 } 3486 }
3499 3487
3500 } // namespace cc 3488 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698