chrome.gpuBenchmarking.printPagesToXPS

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 <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 462 matching lines @@
     float page_shrink = frame->getPrintPageShrink(i);
     DCHECK(page_shrink > 0);
     canvas->scale(page_shrink, page_shrink);
 #endif
 
     frame->printPage(i, canvas);
   }
   frame->printEnd();
 }
 
+static void PrintDocumentTofile(v8::Isolate* isolate,
+                                const std::string& filename,
+                                sk_sp<SkDocument> (*make_doc)(SkWStream*)) {
+  GpuBenchmarkingContext context;
+  if (!context.Init(true))
+    return;
+
+  base::FilePath path = base::FilePath::FromUTF8Unsafe(filename);
+  if (!base::PathIsWritable(path.DirName())) {
+    std::string msg("Path is not writable: ");
+    msg.append(path.DirName().MaybeAsASCII());
+    isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(
+        isolate, msg.c_str(), v8::String::kNormalString, msg.length())));
+    return;
+  }
+  SkFILEWStream wStream(path.MaybeAsASCII().c_str());
+  sk_sp<SkDocument> doc = make_doc(&wStream);
+  if (doc) {
+    context.web_frame()->view()->settings()->setShouldPrintBackgrounds(true);
+    PrintDocument(context.web_frame(), doc.get());
+    doc->close();
+  }
+}
 }  // namespace
 
 gin::WrapperInfo GpuBenchmarking::kWrapperInfo = {gin::kEmbedderNativeGin};
 
 // static
 void GpuBenchmarking::Install(blink::WebFrame* frame) {
   v8::Isolate* isolate = blink::mainThreadIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
   if (context.IsEmpty())
@@ skipping 20 matching lines @@
 gin::ObjectTemplateBuilder GpuBenchmarking::GetObjectTemplateBuilder(
     v8::Isolate* isolate) {
   return gin::Wrappable<GpuBenchmarking>::GetObjectTemplateBuilder(isolate)
       .SetMethod("setNeedsDisplayOnAllLayers",
                  &GpuBenchmarking::SetNeedsDisplayOnAllLayers)
       .SetMethod("setRasterizeOnlyVisibleContent",
                  &GpuBenchmarking::SetRasterizeOnlyVisibleContent)
       .SetMethod("printToSkPicture", &GpuBenchmarking::PrintToSkPicture)
       .SetMethod("printPagesToSkPictures",
                  &GpuBenchmarking::PrintPagesToSkPictures)
+      .SetMethod("printPagesToXPS",
+                 &GpuBenchmarking::PrintPagesToXPS)
       .SetValue("DEFAULT_INPUT", 0)
       .SetValue("TOUCH_INPUT", 1)
       .SetValue("MOUSE_INPUT", 2)
       .SetMethod("gestureSourceTypeSupported",
                  &GpuBenchmarking::GestureSourceTypeSupported)
       .SetMethod("smoothScrollBy", &GpuBenchmarking::SmoothScrollBy)
       .SetMethod("smoothDrag", &GpuBenchmarking::SmoothDrag)
       .SetMethod("swipe", &GpuBenchmarking::Swipe)
       .SetMethod("scrollBounce", &GpuBenchmarking::ScrollBounce)
       .SetMethod("pinchBy", &GpuBenchmarking::PinchBy)
@@ skipping 24 matching lines @@
 void GpuBenchmarking::SetRasterizeOnlyVisibleContent() {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return;
 
   context.compositor()->SetRasterizeOnlyVisibleContent();
 }
 
 void GpuBenchmarking::PrintPagesToSkPictures(v8::Isolate* isolate,
                                              const std::string& filename) {
-  GpuBenchmarkingContext context;
-  if (!context.Init(true))
-    return;
+    PrintDocumentTofile(isolate, filename, &SkMakeMultiPictureDocument);
+}
 
-  base::FilePath path = base::FilePath::FromUTF8Unsafe(filename);
-  if (!base::PathIsWritable(path.DirName())) {
-    std::string msg("Path is not writable: ");
-    msg.append(path.DirName().MaybeAsASCII());
-    isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(
-        isolate, msg.c_str(), v8::String::kNormalString, msg.length())));
-    return;
-  }
-  SkFILEWStream wStream(path.MaybeAsASCII().c_str());
-  sk_sp<SkDocument> doc = SkMakeMultiPictureDocument(&wStream);
-  context.web_frame()->view()->settings()->setShouldPrintBackgrounds(true);
-  PrintDocument(context.web_frame(), doc.get());
-  doc->close();
+void GpuBenchmarking::PrintPagesToXPS(v8::Isolate* isolate,
+                                      const std::string& filename) {
+    PrintDocumentTofile(isolate, filename,
+                        [](SkWStream* s) { return SkDocument::MakeXPS(s); });
 }
 
 void GpuBenchmarking::PrintToSkPicture(v8::Isolate* isolate,
                                        const std::string& dirname) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return;
 
   const cc::Layer* root_layer = context.compositor()->GetRootLayer();
   if (!root_layer)
@@ skipping 433 matching lines @@
           &gpu_driver_bug_workarounds))) {
     return;
   }
 
   v8::Local<v8::Value> result;
   if (gin::TryConvertToV8(args->isolate(), gpu_driver_bug_workarounds, &result))
     args->Return(result);
 }
 
 }  // namespace content