cc: Have 1-copy rasterizer issue copy commands at the rate of raster.

cc/resources/one_copy_raster_worker_pool.h

Index: cc/resources/one_copy_raster_worker_pool.h
diff --git a/cc/resources/one_copy_raster_worker_pool.h b/cc/resources/one_copy_raster_worker_pool.h
index c84b5595e731a3bd4ed8f6f06f94df520e9fb7fc..06e7ea53cace0c800cd76669de66f5a32ded929e 100644
--- a/cc/resources/one_copy_raster_worker_pool.h
+++ b/cc/resources/one_copy_raster_worker_pool.h
@@ -6,10 +6,13 @@
 #define CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_
 
 #include "base/memory/weak_ptr.h"
+#include "base/synchronization/lock.h"
 #include "base/values.h"
+#include "cc/base/scoped_ptr_deque.h"
 #include "cc/output/context_provider.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/rasterizer.h"
+#include "cc/resources/resource_provider.h"
 
 namespace base {
 namespace debug {
@@ -21,7 +24,8 @@ class TracedValue;
 namespace cc {
 class ResourcePool;
 class ResourceProvider;
-class ScopedResource;
+
+typedef int64 CopySequenceNumber;

[vmpstr, 2014/10/22 23:25:17]

Can this be uint64?

[reveman, 2014/10/23 15:38:55]

Yes, but I don't see a good reason for that. style guide explicitly mentions not
using unsigned types just because the value is not supposed to be negative.

 
 class CC_EXPORT OneCopyRasterWorkerPool : public RasterWorkerPool,
                                           public Rasterizer,
@@ -50,6 +54,19 @@ class CC_EXPORT OneCopyRasterWorkerPool : public RasterWorkerPool,
       const Resource* resource) override;
   void ReleaseBufferForRaster(scoped_ptr<RasterBuffer> buffer) override;
 
+  // Schedule copy of |src| resource to |dst| resource. Returns a non-zero
+  // sequence number for this copy operation.
+  CopySequenceNumber ScheduleCopyOnWorkerThread(
+      scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock,
+      const Resource* src,
+      const Resource* dst);
+
+  // Issue copy associated with |sequence| unless already issued.

[vmpstr, 2014/10/22 23:25:17]

Reading the code, this isn't exactly true. This will issue copies for all
"unissued" sequences less or equal to |sequence|, right?

[reveman, 2014/10/23 15:38:55]

Yes, it's not incorrect though. Just doesn't reveal all the details of how this
is done :)

I had some trouble finding names for these functions. I changed it in latest
patch to be more explicit about what it does. PTAL.

+  void IssueCopy(CopySequenceNumber sequence);
+
+  // Flush copy associated with |sequence| unless already flushed.

[vmpstr, 2014/10/22 23:25:17]

Likewise here, I think you should mention that copies will be issued if they
weren't already.

[reveman, 2014/10/23 15:38:55]

PTAL.

+  void FlushCopy(CopySequenceNumber sequence);

[vmpstr, 2014/10/22 23:25:17]

Can this be private? Or does Bind complain?

[reveman, 2014/10/23 15:38:55]

Done.

+
  protected:
   OneCopyRasterWorkerPool(base::SequencedTaskRunner* task_runner,
                           TaskGraphRunner* task_graph_runner,
@@ -58,7 +75,22 @@ class CC_EXPORT OneCopyRasterWorkerPool : public RasterWorkerPool,
                           ResourcePool* resource_pool);
 
  private:
+  struct CopyOperation {
+    typedef ScopedPtrDeque<CopyOperation> Deque;
+
+    CopyOperation(
+        scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock,
+        ResourceProvider::ResourceId src,
+        ResourceProvider::ResourceId dst);
+    ~CopyOperation();
+
+    scoped_ptr<ResourceProvider::ScopedWriteLockGpuMemoryBuffer> write_lock;
+    ResourceProvider::ResourceId src;
+    ResourceProvider::ResourceId dst;
+  };
+
   void OnRasterFinished(TaskSet task_set);
+  void IssueCopyOperations(int64 count);
   scoped_refptr<base::debug::ConvertableToTraceFormat> StateAsValue() const;
   void StagingStateAsValueInto(base::debug::TracedValue* staging_state) const;
 
@@ -71,12 +103,20 @@ class CC_EXPORT OneCopyRasterWorkerPool : public RasterWorkerPool,
   ResourcePool* resource_pool_;
   TaskSetCollection raster_pending_;
   scoped_refptr<RasterizerTask> raster_finished_tasks_[kNumberOfTaskSets];
+  CopySequenceNumber last_issued_copy_operation_;
+  CopySequenceNumber last_flushed_copy_operation_;
 
   // Task graph used when scheduling tasks and vector used to gather
   // completed tasks.
   TaskGraph graph_;
   Task::Vector completed_tasks_;
 
+  base::Lock lock_;
+  // |lock_| must be acquired when accessing the following members.
+  CopyOperation::Deque pending_copy_operations_;
+  CopySequenceNumber next_copy_operation_sequence_;
+
+  base::WeakPtrFactory<OneCopyRasterWorkerPool> weak_ptr_factory_;
   base::WeakPtrFactory<OneCopyRasterWorkerPool>
       raster_finished_weak_ptr_factory_;