Delete chrome.gpuBenchmarking.runRenderingBenchmarks.

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 "content/common/browser_rendering_stats.h"
 #include "content/common/gpu/gpu_rendering_stats.h"
 #include "content/public/renderer/render_thread.h"
-#include "content/renderer/all_rendering_benchmarks.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/rendering_benchmark.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"
@@ skipping 178 matching lines @@
           "                             opt_mouse_event_x, opt_mouse_event_y);"
           "  } else {"
           "    return BeginSmoothScroll(pixels_to_scroll >= 0, callback,"
           "                             Math.abs(pixels_to_scroll));"
           "  }"
           "};"
           "chrome.gpuBenchmarking.smoothScrollBySendsTouch = function() {"
           "  native function SmoothScrollSendsTouch();"
           "  return SmoothScrollSendsTouch();"
           "};"
-          "chrome.gpuBenchmarking.runRenderingBenchmarks = function(filter) {"
-          "  native function RunRenderingBenchmarks();"
-          "  return RunRenderingBenchmarks(filter);"
-          "};"
           "chrome.gpuBenchmarking.beginWindowSnapshotPNG = function(callback) {"
           "  native function BeginWindowSnapshotPNG();"
           "  BeginWindowSnapshotPNG(callback);"
           "};"
           "chrome.gpuBenchmarking.clearImageCache = function() {"
           "  native function ClearImageCache();"
           "  ClearImageCache();"
           "};") {}
 
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<v8::String> name) OVERRIDE {
     if (name->Equals(v8::String::New("SetNeedsDisplayOnAllLayers")))
       return v8::FunctionTemplate::New(SetNeedsDisplayOnAllLayers);
     if (name->Equals(v8::String::New("SetRasterizeOnlyVisibleContent")))
       return v8::FunctionTemplate::New(SetRasterizeOnlyVisibleContent);
     if (name->Equals(v8::String::New("GetRenderingStats")))
       return v8::FunctionTemplate::New(GetRenderingStats);
     if (name->Equals(v8::String::New("PrintToSkPicture")))
       return v8::FunctionTemplate::New(PrintToSkPicture);
     if (name->Equals(v8::String::New("BeginSmoothScroll")))
       return v8::FunctionTemplate::New(BeginSmoothScroll);
     if (name->Equals(v8::String::New("SmoothScrollSendsTouch")))
       return v8::FunctionTemplate::New(SmoothScrollSendsTouch);
-    if (name->Equals(v8::String::New("RunRenderingBenchmarks")))
-      return v8::FunctionTemplate::New(RunRenderingBenchmarks);
     if (name->Equals(v8::String::New("BeginWindowSnapshotPNG")))
       return v8::FunctionTemplate::New(BeginWindowSnapshotPNG);
     if (name->Equals(v8::String::New("ClearImageCache")))
       return v8::FunctionTemplate::New(ClearImageCache);
 
     return v8::Handle<v8::FunctionTemplate>();
   }
 
   static void SetNeedsDisplayOnAllLayers(
       const v8::FunctionCallbackInfo<v8::Value>& args) {
@@ skipping 189 matching lines @@
         scroll_down,
         base::Bind(&OnSmoothScrollCompleted,
                    callback_and_context),
         pixels_to_scroll,
         mouse_event_x,
         mouse_event_y);
 
     args.GetReturnValue().Set(true);
   }
 
-  static void RunRenderingBenchmarks(
-      const v8::FunctionCallbackInfo<v8::Value>& args) {
-    // For our name filter, the argument can be undefined or null to run
-    // all benchmarks, or a string for filtering by name.
-    if (!args.Length() ||
-        (!args[0]->IsString() &&
-         !(args[0]->IsNull() || args[0]->IsUndefined()))) {
-      return;
-    }
-
-    std::string name_filter;
-    if (args[0]->IsNull() || args[0]->IsUndefined()) {
-      name_filter = "";
-    } else {
-      char filter[256];
-      args[0]->ToString()->WriteUtf8(filter, sizeof(filter)-1);
-      name_filter = std::string(filter);
-    }
-
-    WebFrame* web_frame = WebFrame::frameForCurrentContext();
-    if (!web_frame)
-      return;
-
-    WebView* web_view = web_frame->view();
-    if (!web_view)
-      return;
-
-    WebViewBenchmarkSupport* support = web_view->benchmarkSupport();
-    if (!support)
-      return;
-
-    ScopedVector<RenderingBenchmark> benchmarks = AllRenderingBenchmarks();
-
-    v8::Handle<v8::Array> results = v8::Array::New(0);
-    ScopedVector<RenderingBenchmark>::const_iterator it;
-    for (it = benchmarks.begin(); it != benchmarks.end(); it++) {
-      RenderingBenchmark* benchmark = *it;
-      const std::string& name = benchmark->name();
-      if (name_filter != "" &&
-          std::string::npos == name.find(name_filter)) {
-        continue;
-      }
-      benchmark->SetUp(support);
-      double result = benchmark->Run(support);
-      benchmark->TearDown(support);
-
-      v8::Handle<v8::Object> result_object = v8::Object::New();
-      result_object->Set(v8::String::New("benchmark", 9),
-                         v8::String::New(name.c_str(), -1));
-      result_object->Set(v8::String::New("result", 6), v8::Number::New(result));
-      results->Set(results->Length(), result_object);
-    }
-
-    args.GetReturnValue().Set(results);
-  }
-
   static void OnSnapshotCompleted(CallbackAndContext* callback_and_context,
                                   const gfx::Size& size,
                                   const std::vector<unsigned char>& png) {
     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) {
 
       v8::Handle<v8::Value> result;
@@ skipping 60 matching lines @@
       const v8::FunctionCallbackInfo<v8::Value>& args) {
     WebImageCache::clear();
   }
 };
 
 v8::Extension* GpuBenchmarkingExtension::Get() {
   return new GpuBenchmarkingWrapper();
 }
 
 }  // namespace content