cc: Do bitmap conversion for RasterBuffer in the worker thread.

cc/resources/tile_manager.cc

 // Copyright 2012 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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 75 matching lines @@
     reply_.Run(analysis_, !HasFinishedRunning());
   }
 
  protected:
   virtual ~RasterTaskImpl() { DCHECK(!canvas_); }
 
  private:
   void AnalyzeAndRaster(PicturePileImpl* picture_pile) {
     DCHECK(picture_pile);
     DCHECK(canvas_);
+    DCHECK(canvas_->GetSkCanvas());
 
     if (analyze_picture_) {
       Analyze(picture_pile);
       if (analysis_.is_solid_color)
         return;
     }
 
     Raster(picture_pile);
+
+    canvas_->Flush();
   }
 
   void Analyze(PicturePileImpl* picture_pile) {
     frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task(
         tile_id_, tile_resolution_, source_frame_number_, layer_id_);
 
     DCHECK(picture_pile);
 
     picture_pile->AnalyzeInRect(
         content_rect_, contents_scale_, &analysis_, rendering_stats_);
@@ skipping 20 matching lines @@
     switch (raster_mode_) {
       case LOW_QUALITY_RASTER_MODE:
         draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
         break;
       case HIGH_QUALITY_RASTER_MODE:
         break;
       case NUM_RASTER_MODES:
       default:
         NOTREACHED();
     }
-    canvas_->setDrawFilter(draw_filter.get());
+    canvas_->GetSkCanvas()->setDrawFilter(draw_filter.get());
 
     base::TimeDelta prev_rasterize_time =
         rendering_stats_->impl_thread_rendering_stats().rasterize_time;
 
     // Only record rasterization time for highres tiles, because
     // lowres tiles are not required for activation and therefore
     // introduce noise in the measurement (sometimes they get rasterized
     // before we draw and sometimes they aren't)
     RenderingStatsInstrumentation* stats =
         tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL;
     DCHECK(picture_pile);
     picture_pile->RasterToBitmap(
-        canvas_, content_rect_, contents_scale_, stats);
+        canvas_->GetSkCanvas(), content_rect_, contents_scale_, stats);
 
     if (rendering_stats_->record_rendering_stats()) {
       base::TimeDelta current_rasterize_time =
           rendering_stats_->impl_thread_rendering_stats().rasterize_time;
       HISTOGRAM_CUSTOM_COUNTS(
           "Renderer4.PictureRasterTimeUS",
           (current_rasterize_time - prev_rasterize_time).InMicroseconds(),
           0,
           100000,
           100);
     }
   }
 
   PicturePileImpl::Analysis analysis_;
   scoped_refptr<PicturePileImpl> picture_pile_;
   gfx::Rect content_rect_;
   float contents_scale_;
   RasterMode raster_mode_;
   TileResolution tile_resolution_;
   int layer_id_;
   const void* tile_id_;
   int source_frame_number_;
   bool analyze_picture_;
   RenderingStatsInstrumentation* rendering_stats_;
   const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_;
-  SkCanvas* canvas_;
+  RasterCanvas* canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 };
 
 class ImageDecodeTaskImpl : public ImageDecodeTask {
  public:
   ImageDecodeTaskImpl(SkPixelRef* pixel_ref,
                       int layer_id,
                       RenderingStatsInstrumentation* rendering_stats,
                       const base::Callback<void(bool was_canceled)>& reply)
@@ skipping 987 matching lines @@
   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
 
   rasterizer_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   if (IsReadyToActivate())
     client_->NotifyReadyToActivate();
 }
 
 }  // namespace cc