Add a flag to disable partial raster in renderer

cc/raster/one_copy_tile_task_worker_pool.cc

 // Copyright 2014 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/raster/one_copy_tile_task_worker_pool.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/strings/stringprintf.h"
@@ skipping 156 matching lines @@
   pmd->AddOwnershipEdge(buffer_dump->guid(), shared_buffer_guid, kImportance);
 }
 
 // static
 scoped_ptr<TileTaskWorkerPool> OneCopyTileTaskWorkerPool::Create(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ContextProvider* context_provider,
     ResourceProvider* resource_provider,
     int max_copy_texture_chromium_size,
-    bool use_persistent_gpu_memory_buffers,
+    bool use_partial_raster,
     int max_staging_buffer_usage_in_bytes,
     bool use_rgba_4444_texture_format) {
   return make_scoped_ptr<TileTaskWorkerPool>(new OneCopyTileTaskWorkerPool(
       task_runner, task_graph_runner, resource_provider,
-      max_copy_texture_chromium_size, use_persistent_gpu_memory_buffers,
+      max_copy_texture_chromium_size, use_partial_raster,
       max_staging_buffer_usage_in_bytes, use_rgba_4444_texture_format));
 }
 
 OneCopyTileTaskWorkerPool::OneCopyTileTaskWorkerPool(
     base::SequencedTaskRunner* task_runner,
     TaskGraphRunner* task_graph_runner,
     ResourceProvider* resource_provider,
     int max_copy_texture_chromium_size,
-    bool use_persistent_gpu_memory_buffers,
+    bool use_partial_raster,
     int max_staging_buffer_usage_in_bytes,
     bool use_rgba_4444_texture_format)
     : task_runner_(task_runner),
       task_graph_runner_(task_graph_runner),
       namespace_token_(task_graph_runner->GetNamespaceToken()),
       resource_provider_(resource_provider),
       max_bytes_per_copy_operation_(
           max_copy_texture_chromium_size
               ? std::min(kMaxBytesPerCopyOperation,
                          max_copy_texture_chromium_size)
               : kMaxBytesPerCopyOperation),
-      use_persistent_gpu_memory_buffers_(use_persistent_gpu_memory_buffers),
+      use_partial_raster_(use_partial_raster),
       bytes_scheduled_since_last_flush_(0),
       max_staging_buffer_usage_in_bytes_(max_staging_buffer_usage_in_bytes),
       use_rgba_4444_texture_format_(use_rgba_4444_texture_format),
       staging_buffer_usage_in_bytes_(0),
       free_staging_buffer_usage_in_bytes_(0),
       staging_buffer_expiration_delay_(
           base::TimeDelta::FromMilliseconds(kStagingBufferExpirationDelayMs)),
       reduce_memory_usage_pending_(false),
       weak_ptr_factory_(this),
       task_set_finished_weak_ptr_factory_(this) {
@@ skipping 162 matching lines @@
     uint64_t new_content_id) {
   base::AutoLock lock(lock_);
 
   scoped_ptr<StagingBuffer> staging_buffer =
       AcquireStagingBuffer(resource, previous_content_id);
   DCHECK(staging_buffer);
 
   {
     base::AutoUnlock unlock(lock_);
 
-    // Allocate GpuMemoryBuffer if necessary.
+    // Allocate GpuMemoryBuffer if necessary. If using partial raster, we
+    // must allocate a buffer with BufferUsage PERSISTENT_MAP.
     if (!staging_buffer->gpu_memory_buffer) {
       staging_buffer->gpu_memory_buffer =
           resource_provider_->gpu_memory_buffer_manager()
-              ->AllocateGpuMemoryBuffer(staging_buffer->size,
-                                        BufferFormat(resource->format()),
-                                        use_persistent_gpu_memory_buffers_
-                                            ? gfx::BufferUsage::PERSISTENT_MAP
-                                            : gfx::BufferUsage::MAP);
+              ->AllocateGpuMemoryBuffer(
+                  staging_buffer->size, BufferFormat(resource->format()),
+                  use_partial_raster_ ? gfx::BufferUsage::PERSISTENT_MAP
+                                      : gfx::BufferUsage::MAP);
       DCHECK_EQ(gfx::NumberOfPlanesForBufferFormat(
                     staging_buffer->gpu_memory_buffer->GetFormat()),
                 1u);
     }
 
     gfx::Rect playback_rect = raster_full_rect;
-    if (use_persistent_gpu_memory_buffers_ && previous_content_id) {
+    if (use_partial_raster_ && previous_content_id) {
       // Reduce playback rect to dirty region if the content id of the staging
       // buffer matches the prevous content id.
       if (previous_content_id == staging_buffer->content_id)
         playback_rect.Intersect(raster_dirty_rect);
     }
 
     if (staging_buffer->gpu_memory_buffer) {
       void* data = nullptr;
       bool rv = staging_buffer->gpu_memory_buffer->Map(&data);
       DCHECK(rv);
@@ skipping 218 matching lines @@
       gl->Finish();
       while (!busy_buffers_.empty()) {
         MarkStagingBufferAsFree(busy_buffers_.front());
         free_buffers_.push_back(busy_buffers_.take_front());
       }
     }
   }
 
   // Find a staging buffer that allows us to perform partial raster when
   // using persistent GpuMemoryBuffers.
-  if (use_persistent_gpu_memory_buffers_ && previous_content_id) {
+  if (use_partial_raster_ && previous_content_id) {
     StagingBufferDeque::iterator it =
         std::find_if(free_buffers_.begin(), free_buffers_.end(),
                      [previous_content_id](const StagingBuffer* buffer) {
                        return buffer->content_id == previous_content_id;
                      });
     if (it != free_buffers_.end()) {
       staging_buffer = free_buffers_.take(it);
       MarkStagingBufferAsBusy(staging_buffer.get());
     }
   }
@@ skipping 160 matching lines @@
 
   staging_state->SetInteger("staging_buffer_count",
                             static_cast<int>(buffers_.size()));
   staging_state->SetInteger("busy_count",
                             static_cast<int>(busy_buffers_.size()));
   staging_state->SetInteger("free_count",
                             static_cast<int>(free_buffers_.size()));
 }
 
 }  // namespace cc