cc: Use max_bytes_per_copy_operation setting to determine one-copy flush interval.

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 81 matching lines @@
   ResourcePool* resource_pool_;
   const Resource* output_resource_;
   uint64_t raster_content_id_;
   scoped_ptr<ScopedResource> raster_resource_;
   scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> lock_;
   CopySequenceNumber sequence_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterBufferImpl);
 };
 
-// Flush interval when performing copy operations.
-const int kCopyFlushPeriod = 4;
-
 // Number of in-flight copy operations to allow.
 const int kMaxCopyOperations = 32;
 
 // Delay been checking for copy operations to complete.
 const int kCheckForCompletedCopyOperationsTickRateMs = 1;
 
 // Number of failed attempts to allow before we perform a check that will
 // wait for copy operations to complete if needed.
 const int kFailedAttemptsBeforeWaitIfNeeded = 256;
 
@@ skipping 38 matching lines @@
       namespace_token_(task_graph_runner->GetNamespaceToken()),
       context_provider_(context_provider),
       resource_provider_(resource_provider),
       resource_pool_(resource_pool),
       max_bytes_per_copy_operation_(max_bytes_per_copy_operation),
       have_persistent_gpu_memory_buffers_(have_persistent_gpu_memory_buffers),
       last_issued_copy_operation_(0),
       last_flushed_copy_operation_(0),
       lock_(),
       copy_operation_count_cv_(&lock_),
+      bytes_scheduled_since_last_flush_(0),
       issued_copy_operation_count_(0),
       next_copy_operation_sequence_(1),
       check_for_completed_copy_operations_pending_(false),
       shutdown_(false),
       weak_ptr_factory_(this),
       task_set_finished_weak_ptr_factory_(this) {
   DCHECK(context_provider_);
 }
 
 OneCopyTileTaskWorkerPool::~OneCopyTileTaskWorkerPool() {
@@ skipping 221 matching lines @@
     // |raster_resource_write_lock| is passed to the first copy operation as it
     // needs to be released before we can issue a copy.
     pending_copy_operations_.push_back(make_scoped_ptr(new CopyOperation(
         raster_resource_write_lock.Pass(), raster_resource, output_resource,
         gfx::Rect(0, y, raster_resource->size().width(), rows_to_copy))));
     y += rows_to_copy;
 
     // Acquire a sequence number for this copy operation.
     sequence = next_copy_operation_sequence_++;
 
+    // Increment |bytes_scheduled_since_last_flush_| by the amount of memory
+    // used for this copy operation.
+    bytes_scheduled_since_last_flush_ += rows_to_copy * bytes_per_row;
+
     // Post task that will advance last flushed copy operation to |sequence|
-    // if we have reached the flush period.
-    if ((sequence % kCopyFlushPeriod) == 0) {
+    // when |bytes_scheduled_since_last_flush_| has reached
+    // |max_bytes_per_copy_operation_|.
+    if (bytes_scheduled_since_last_flush_ >= max_bytes_per_copy_operation_) {
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&OneCopyTileTaskWorkerPool::AdvanceLastFlushedCopyTo,
                      weak_ptr_factory_.GetWeakPtr(), sequence));
+      bytes_scheduled_since_last_flush_ = 0;
     }
   }
 
   return sequence;
 }
 
 void OneCopyTileTaskWorkerPool::AdvanceLastIssuedCopyTo(
     CopySequenceNumber sequence) {
   if (last_issued_copy_operation_ >= sequence)
     return;
@@ skipping 143 matching lines @@
       "pending_copy_count",
       static_cast<int>(resource_pool_->total_resource_count() -
                        resource_pool_->acquired_resource_count()));
   staging_state->SetInteger(
       "bytes_pending_copy",
       static_cast<int>(resource_pool_->total_memory_usage_bytes() -
                        resource_pool_->acquired_memory_usage_bytes()));
 }
 
 }  // namespace cc