cc: Partial tile update for one-copy raster.

cc/raster/gpu_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/gpu_tile_task_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/playback/raster_source.h"
@@ skipping 12 matching lines @@
 
 class RasterBufferImpl : public RasterBuffer {
  public:
   RasterBufferImpl(GpuRasterizer* rasterizer, const Resource* resource)
       : rasterizer_(rasterizer),
         lock_(rasterizer->resource_provider(), resource->id()),
         resource_(resource) {}
 
   // Overridden from RasterBuffer:
   void Playback(const RasterSource* raster_source,
-                const gfx::Rect& rect,
+                const gfx::Rect& raster_full_rect,
+                const gfx::Rect& raster_dirty_rect,
                 float scale) override {
     TRACE_EVENT0("cc", "RasterBufferImpl::Playback");
     ContextProvider* context_provider = rasterizer_->resource_provider()
                                             ->output_surface()
                                             ->worker_context_provider();
 
     // The context lock must be held while accessing the context on a
     // worker thread.
     base::AutoLock context_lock(*context_provider->GetLock());
 
     // Allow this worker thread to bind to context_provider.
     context_provider->DetachFromThread();
 
+    // TODO(danakj): Implement partial raster with raster_dirty_rect.
     // Rasterize source into resource.
-    rasterizer_->RasterizeSource(&lock_, raster_source, rect, scale);
+    rasterizer_->RasterizeSource(&lock_, raster_source, raster_full_rect,
+                                 scale);
 
     // Barrier to sync worker context output to cc context.
     context_provider->ContextGL()->OrderingBarrierCHROMIUM();
 
     // Allow compositor thread to bind to context_provider.
     context_provider->DetachFromThread();
   }
 
  private:
   GpuRasterizer* rasterizer_;
@@ skipping 141 matching lines @@
     raster_task->WillComplete();
     raster_task->CompleteOnOriginThread(this);
     raster_task->DidComplete();
 
     raster_task->RunReplyOnOriginThread();
   }
   completed_tasks_.clear();
 }
 
 scoped_ptr<RasterBuffer> GpuTileTaskWorkerPool::AcquireBufferForRaster(
-    const Resource* resource) {
+    const TileTaskData& data) {
   return make_scoped_ptr<RasterBuffer>(
-      new RasterBufferImpl(rasterizer_.get(), resource));
+      new RasterBufferImpl(rasterizer_.get(), data.resource));
 }
 
 void GpuTileTaskWorkerPool::ReleaseBufferForRaster(
     scoped_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
 void GpuTileTaskWorkerPool::OnTaskSetFinished(TaskSet task_set) {
   TRACE_EVENT1("cc", "GpuTileTaskWorkerPool::OnTaskSetFinished", "task_set",
                task_set);
 
   DCHECK(tasks_pending_[task_set]);
   tasks_pending_[task_set] = false;
   client_->DidFinishRunningTileTasks(task_set);
 }
 
 }  // namespace cc