Remove window.chrome.gpuBenchmarking.beginWindowSnapshotPNG

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/files/file_path.h"
@@ skipping 246 matching lines @@
     v8::Handle<v8::Value> argv[] = { value };
 
     frame->callFunctionEvenIfScriptDisabled(
         callback_and_context->GetCallback(),
         v8::Object::New(isolate),
         1,
         argv);
   }
 }
 
-void OnSnapshotCompleted(CallbackAndContext* callback_and_context,
-                         const gfx::Size& size,
-                         const std::vector<unsigned char>& png) {
-  v8::Isolate* isolate = callback_and_context->isolate();
-  v8::HandleScope scope(isolate);
-  v8::Handle<v8::Context> context = callback_and_context->GetContext();
-  v8::Context::Scope context_scope(context);
-  WebLocalFrame* frame = WebLocalFrame::frameForContext(context);
-  if (frame) {
-    v8::Handle<v8::Value> result;
-
-    if (!size.IsEmpty()) {
-      v8::Handle<v8::Object> result_object;
-      result_object = v8::Object::New(isolate);
-
-      result_object->Set(v8::String::NewFromUtf8(isolate, "width"),
-                         v8::Number::New(isolate, size.width()));
-      result_object->Set(v8::String::NewFromUtf8(isolate, "height"),
-                         v8::Number::New(isolate, size.height()));
-
-      std::string base64_png;
-      base::Base64Encode(
-          base::StringPiece(reinterpret_cast<const char*>(&*png.begin()),
-                            png.size()),
-          &base64_png);
-
-      result_object->Set(v8::String::NewFromUtf8(isolate, "data"),
-                         v8::String::NewFromUtf8(isolate,
-                                                 base64_png.c_str(),
-                                                 v8::String::kNormalString,
-                                                 base64_png.size()));
-
-      result = result_object;
-    } else {
-      result = v8::Null(isolate);
-    }
-
-    v8::Handle<v8::Value> argv[] = {result};
-
-    frame->callFunctionEvenIfScriptDisabled(
-        callback_and_context->GetCallback(), v8::Object::New(isolate), 1, argv);
-  }
-}
-
 void OnSyntheticGestureCompleted(CallbackAndContext* callback_and_context) {
   v8::Isolate* isolate = callback_and_context->isolate();
   v8::HandleScope scope(isolate);
   v8::Handle<v8::Context> context = callback_and_context->GetContext();
   v8::Context::Scope context_scope(context);
   WebLocalFrame* frame = WebLocalFrame::frameForContext(context);
   if (frame) {
     frame->callFunctionEvenIfScriptDisabled(
         callback_and_context->GetCallback(), v8::Object::New(isolate), 0, NULL);
   }
@@ skipping 160 matching lines @@
                  &GpuBenchmarking::GestureSourceTypeSupported)
       .SetMethod("smoothScrollBy", &GpuBenchmarking::SmoothScrollBy)
       .SetMethod("smoothDrag", &GpuBenchmarking::SmoothDrag)
       .SetMethod("swipe", &GpuBenchmarking::Swipe)
       .SetMethod("scrollBounce", &GpuBenchmarking::ScrollBounce)
       // TODO(dominikg): Remove once JS interface changes have rolled into
       //                 stable.
       .SetValue("newPinchInterface", true)
       .SetMethod("pinchBy", &GpuBenchmarking::PinchBy)
       .SetMethod("tap", &GpuBenchmarking::Tap)
-      .SetMethod("beginWindowSnapshotPNG",
-                 &GpuBenchmarking::BeginWindowSnapshotPNG)
       .SetMethod("clearImageCache", &GpuBenchmarking::ClearImageCache)
       .SetMethod("runMicroBenchmark", &GpuBenchmarking::RunMicroBenchmark)
       .SetMethod("sendMessageToMicroBenchmark",
                  &GpuBenchmarking::SendMessageToMicroBenchmark)
       .SetMethod("hasGpuProcess", &GpuBenchmarking::HasGpuProcess);
 }
 
 void GpuBenchmarking::SetNeedsDisplayOnAllLayers() {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
@@ skipping 319 matching lines @@
   // TODO(nduca): If the render_view_impl is destroyed while the gesture is in
   // progress, we will leak the callback and context. This needs to be fixed,
   // somehow.
   context.render_view_impl()->QueueSyntheticGesture(
       gesture_params.Pass(),
       base::Bind(&OnSyntheticGestureCompleted, callback_and_context));
 
   return true;
 }
 
-void GpuBenchmarking::BeginWindowSnapshotPNG(
-    v8::Isolate* isolate,
-    v8::Handle<v8::Function> callback) {
-  GpuBenchmarkingContext context;
-  if (!context.Init(false))
-    return;
-
-  scoped_refptr<CallbackAndContext> callback_and_context =
-      new CallbackAndContext(isolate,
-                             callback,
-                             context.web_frame()->mainWorldScriptContext());
-
-  context.render_view_impl()->GetWindowSnapshot(
-      base::Bind(&OnSnapshotCompleted, callback_and_context));
-}
-
 void GpuBenchmarking::ClearImageCache() {
   WebImageCache::clear();
 }
 
 int GpuBenchmarking::RunMicroBenchmark(gin::Arguments* args) {
   GpuBenchmarkingContext context;
   if (!context.Init(true))
     return 0;
 
   std::string name;
@@ skipping 38 matching lines @@
 
   return context.compositor()->SendMessageToMicroBenchmark(id, value.Pass());
 }
 
 bool GpuBenchmarking::HasGpuProcess() {
     GpuChannelHost* gpu_channel = RenderThreadImpl::current()->GetGpuChannel();
     return !!gpu_channel;
 }
 
 }  // namespace content