Implemented printToSkPicture without using WebViewBenchmarkSupport.

content/renderer/gpu/gpu_benchmarking_extension.cc

 // Copyright (c) 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 "content/renderer/gpu/gpu_benchmarking_extension.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
+#include "cc/layers/layer.h"
 #include "content/common/browser_rendering_stats.h"
 #include "content/common/gpu/gpu_rendering_stats.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/skia_benchmarking_extension.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebImageCache.h"
 #include "third_party/WebKit/public/web/WebView.h"
-#include "third_party/WebKit/public/web/WebViewBenchmarkSupport.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "v8/include/v8.h"
 #include "webkit/renderer/compositor_bindings/web_rendering_stats_impl.h"
 
 using WebKit::WebCanvas;
@@ skipping 18 matching lines @@
     }
     std::vector<unsigned char> vector;
     if (gfx::PNGCodec::EncodeBGRASkBitmap(bm, false, &vector)) {
         return SkData::NewWithCopy(&vector.front() , vector.size());
     }
     return NULL;
 }
 
 namespace {
 
-class SkPictureRecorder : public WebViewBenchmarkSupport::PaintClient {
+class SkPictureSerializer {
  public:
-  explicit SkPictureRecorder(const base::FilePath& dirpath)
+  explicit SkPictureSerializer(const base::FilePath& dirpath)
       : dirpath_(dirpath),
         layer_id_(0) {
     // Let skia register known effect subclasses. This basically enables
     // reflection on those subclasses required for picture serialization.
     content::SkiaBenchmarkingExtension::InitSkGraphics();
   }
 
-  virtual WebCanvas* willPaint(const WebSize& size) {
-    return picture_.beginRecording(size.width, size.height);
-  }
+  // Recursively serializes the layer tree.
+  // Each layer in the tree is serialized into a separate skp file
+  // in the given directory.
+  void Serialize(const cc::Layer* layer) {
+    // First serialize the children to avoid keeping too much stuff on stack.
+    const cc::LayerList& children = layer->children();
+    for (size_t i = 0; i < children.size(); ++i) {
+      Serialize(children[i].get());
+    }
 
-  virtual void didPaint(WebCanvas* canvas) {
-    DCHECK(canvas == picture_.getRecordingCanvas());
-    picture_.endRecording();
+    skia::RefPtr<SkPicture> picture = layer->GetPicture();
+    if (!picture)
+      return;
+
     // Serialize picture to file.
     // TODO(alokp): Note that for this to work Chrome needs to be launched with
     // --no-sandbox command-line flag. Get rid of this limitation.
     // CRBUG: 139640.
     std::string filename = "layer_" + base::IntToString(layer_id_++) + ".skp";
     std::string filepath = dirpath_.AppendASCII(filename).MaybeAsASCII();
     DCHECK(!filepath.empty());
     SkFILEWStream file(filepath.c_str());
     DCHECK(file.isValid());
-    picture_.serialize(&file, &EncodeBitmapToData);
+    picture->serialize(&file, &EncodeBitmapToData);
   }
 
  private:
   base::FilePath dirpath_;
   int layer_id_;
-  SkPicture picture_;
 };
 
 class RenderingStatsEnumerator : public cc::RenderingStats::Enumerator {
  public:
   RenderingStatsEnumerator(v8::Handle<v8::Object> stats_object)
       : stats_object(stats_object) { }
 
   virtual void AddInt64(const char* name, int64 value) OVERRIDE {
     stats_object->Set(v8::String::New(name), v8::Number::New(value));
   }
@@ skipping 221 matching lines @@
       return;
 
     WebFrame* web_frame = WebFrame::frameForCurrentContext();
     if (!web_frame)
       return;
 
     WebView* web_view = web_frame->view();
     if (!web_view)
       return;
 
-    WebViewBenchmarkSupport* benchmark_support = web_view->benchmarkSupport();
-    if (!benchmark_support)
+    RenderViewImpl* render_view_impl = RenderViewImpl::FromWebView(web_view);
+    if (!render_view_impl)
+      return;
+
+    RenderWidgetCompositor* compositor = render_view_impl->compositor();
+    if (!compositor)
+      return;
+
+    const cc::Layer* root_layer = compositor->GetRootLayer();
+    if (!root_layer)
       return;
 
     base::FilePath dirpath(
         base::FilePath::StringType(*dirname, *dirname + dirname.length()));
     if (!file_util::CreateDirectory(dirpath) ||
         !base::PathIsWritable(dirpath)) {
       std::string msg("Path is not writable: ");
       msg.append(dirpath.MaybeAsASCII());
       v8::ThrowException(v8::Exception::Error(
           v8::String::New(msg.c_str(), msg.length())));
       return;
     }
 
-    SkPictureRecorder recorder(dirpath);
-    benchmark_support->paint(&recorder,
-                             WebViewBenchmarkSupport::PaintModeEverything);
+    SkPictureSerializer serializer(dirpath);
+    serializer.Serialize(root_layer);
   }
 
   static void OnSmoothScrollCompleted(
       CallbackAndContext* callback_and_context) {
     v8::HandleScope scope(callback_and_context->isolate());
     v8::Handle<v8::Context> context = callback_and_context->GetContext();
     v8::Context::Scope context_scope(context);
     WebFrame* frame = WebFrame::frameForContext(context);
     if (frame) {
       frame->callFunctionEvenIfScriptDisabled(
@@ skipping 152 matching lines @@
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     WebImageCache::clear();
   }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content