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

cc/resources/one_copy_raster_worker_pool.h

 // 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.
 
 #ifndef CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_
 #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 {
 class ConvertableToTraceFormat;
 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,
                                           public RasterizerTaskClient {
  public:
   ~OneCopyRasterWorkerPool() override;
 
   static scoped_ptr<RasterWorkerPool> Create(
       base::SequencedTaskRunner* task_runner,
       TaskGraphRunner* task_graph_runner,
       ContextProvider* context_provider,
       ResourceProvider* resource_provider,
       ResourcePool* resource_pool);
 
   // Overridden from RasterWorkerPool:
   Rasterizer* AsRasterizer() override;
 
   // Overridden from Rasterizer:
   void SetClient(RasterizerClient* client) override;
   void Shutdown() override;
   void ScheduleTasks(RasterTaskQueue* queue) override;
   void CheckForCompletedTasks() override;
 
   // Overridden from RasterizerTaskClient:
   scoped_ptr<RasterBuffer> AcquireBufferForRaster(
       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,
                           ContextProvider* context_provider,
                           ResourceProvider* resource_provider,
                           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;
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   TaskGraphRunner* task_graph_runner_;
   const NamespaceToken namespace_token_;
   RasterizerClient* client_;
   ContextProvider* context_provider_;
   ResourceProvider* resource_provider_;
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(OneCopyRasterWorkerPool);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_ONE_COPY_RASTER_WORKER_POOL_H_