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

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: rebase 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
« no previous file with comments | « no previous file | cc/trees/layer_tree_settings.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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 1821 matching lines...) Expand 10 before | Expand all | Expand 10 after
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 = 1992 bool should_use_zero_copy_rasterizer =
2009 settings_.use_zero_copy || IsSynchronousSingleThreaded(); 1993 settings_.use_zero_copy || IsSynchronousSingleThreaded();
2010 1994
1995 unsigned image_target = GL_TEXTURE_2D;
1996 #if defined(OS_MACOSX)
1997 // GL_TEXTURE_RECTANGLE_ARB target is required by IOSurface backed images.
1998 DCHECK(context_provider->ContextCapabilities().gpu.texture_rectangle);
piman 2014/11/25 18:12:21 Would it make sense to ask the GpuMemoryBufferImpl
reveman 2014/11/25 19:36:11 Maybe. I'm not sure I want the concept of GL textu
1999 image_target = GL_TEXTURE_RECTANGLE_ARB;
2000 #endif
2001 if (settings_.use_image_external) {
2002 DCHECK(context_provider->ContextCapabilities().gpu.egl_image_external);
2003 image_target = GL_TEXTURE_EXTERNAL_OES;
2004 }
2005
2011 if (!context_provider) { 2006 if (!context_provider) {
2012 *resource_pool = 2007 *resource_pool =
2013 ResourcePool::Create(resource_provider_.get(), 2008 ResourcePool::Create(resource_provider_.get(),
2014 GL_TEXTURE_2D, 2009 GL_TEXTURE_2D,
2015 resource_provider_->best_texture_format()); 2010 resource_provider_->best_texture_format());
2016 2011
2017 *raster_worker_pool = 2012 *raster_worker_pool =
2018 BitmapRasterWorkerPool::Create(task_runner, 2013 BitmapRasterWorkerPool::Create(task_runner,
2019 RasterWorkerPool::GetTaskGraphRunner(), 2014 RasterWorkerPool::GetTaskGraphRunner(),
2020 resource_provider_.get()); 2015 resource_provider_.get());
2021 } else if (use_gpu_rasterization_) { 2016 } else if (use_gpu_rasterization_) {
2022 *resource_pool = 2017 *resource_pool =
2023 ResourcePool::Create(resource_provider_.get(), 2018 ResourcePool::Create(resource_provider_.get(),
2024 GL_TEXTURE_2D, 2019 GL_TEXTURE_2D,
2025 resource_provider_->best_texture_format()); 2020 resource_provider_->best_texture_format());
2026 2021
2027 *raster_worker_pool = 2022 *raster_worker_pool =
2028 GpuRasterWorkerPool::Create(task_runner, 2023 GpuRasterWorkerPool::Create(task_runner,
2029 context_provider, 2024 context_provider,
2030 resource_provider_.get(), 2025 resource_provider_.get(),
2031 settings_.use_distance_field_text); 2026 settings_.use_distance_field_text);
2032 } else if (should_use_zero_copy_rasterizer && CanUseZeroCopyRasterizer()) { 2027 } else if (should_use_zero_copy_rasterizer && CanUseZeroCopyRasterizer()) {
2033 *resource_pool = ResourcePool::Create( 2028 *resource_pool =
2034 resource_provider_.get(), 2029 ResourcePool::Create(resource_provider_.get(), image_target,
2035 GetMapImageTextureTarget(context_provider->ContextCapabilities()), 2030 resource_provider_->best_texture_format());
2036 resource_provider_->best_texture_format());
2037 2031
2038 TaskGraphRunner* task_graph_runner; 2032 TaskGraphRunner* task_graph_runner;
2039 if (IsSynchronousSingleThreaded()) { 2033 if (IsSynchronousSingleThreaded()) {
2040 DCHECK(!single_thread_synchronous_task_graph_runner_); 2034 DCHECK(!single_thread_synchronous_task_graph_runner_);
2041 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner); 2035 single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
2042 task_graph_runner = single_thread_synchronous_task_graph_runner_.get(); 2036 task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
2043 } else { 2037 } else {
2044 task_graph_runner = RasterWorkerPool::GetTaskGraphRunner(); 2038 task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
2045 } 2039 }
2046 2040
2047 *raster_worker_pool = ZeroCopyRasterWorkerPool::Create( 2041 *raster_worker_pool = ZeroCopyRasterWorkerPool::Create(
2048 task_runner, task_graph_runner, resource_provider_.get()); 2042 task_runner, task_graph_runner, resource_provider_.get());
2049 } else if (settings_.use_one_copy && CanUseOneCopyRasterizer()) { 2043 } else if (settings_.use_one_copy && CanUseOneCopyRasterizer()) {
2050 // We need to create a staging resource pool when using copy rasterizer. 2044 // We need to create a staging resource pool when using copy rasterizer.
2051 *staging_resource_pool = ResourcePool::Create( 2045 *staging_resource_pool =
2052 resource_provider_.get(), 2046 ResourcePool::Create(resource_provider_.get(), image_target,
2053 GetMapImageTextureTarget(context_provider->ContextCapabilities()), 2047 resource_provider_->best_texture_format());
2054 resource_provider_->best_texture_format());
2055 *resource_pool = 2048 *resource_pool =
2056 ResourcePool::Create(resource_provider_.get(), 2049 ResourcePool::Create(resource_provider_.get(),
2057 GL_TEXTURE_2D, 2050 GL_TEXTURE_2D,
2058 resource_provider_->best_texture_format()); 2051 resource_provider_->best_texture_format());
2059 2052
2060 *raster_worker_pool = 2053 *raster_worker_pool =
2061 OneCopyRasterWorkerPool::Create(task_runner, 2054 OneCopyRasterWorkerPool::Create(task_runner,
2062 RasterWorkerPool::GetTaskGraphRunner(), 2055 RasterWorkerPool::GetTaskGraphRunner(),
2063 context_provider, 2056 context_provider,
2064 resource_provider_.get(), 2057 resource_provider_.get(),
(...skipping 1426 matching lines...) Expand 10 before | Expand all | Expand 10 after
3491 } 3484 }
3492 3485
3493 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) { 3486 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
3494 std::vector<PictureLayerImpl*>::iterator it = 3487 std::vector<PictureLayerImpl*>::iterator it =
3495 std::find(picture_layers_.begin(), picture_layers_.end(), layer); 3488 std::find(picture_layers_.begin(), picture_layers_.end(), layer);
3496 DCHECK(it != picture_layers_.end()); 3489 DCHECK(it != picture_layers_.end());
3497 picture_layers_.erase(it); 3490 picture_layers_.erase(it);
3498 } 3491 }
3499 3492
3500 } // namespace cc 3493 } // namespace cc
OLDNEW
« no previous file with comments | « no previous file | cc/trees/layer_tree_settings.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698