chrome/renderer/net_benchmarking_extension.cc

   1 // Copyright 2013 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/renderer/net_benchmarking_extension.h"
   6
   7 #include "base/no_destructor.h"
   8 #include "chrome/common/net_benchmarking.mojom.h"
   9 #include "content/public/renderer/render_thread.h"
  10 #include "mojo/public/cpp/bindings/remote.h"
  11 #include "third_party/blink/public/platform/web_cache.h"
  12 #include "v8/include/v8-extension.h"
  13 #include "v8/include/v8-primitive.h"
  14 #include "v8/include/v8-template.h"
  15
  16 using blink::WebCache;
  17
  18 const char kNetBenchmarkingExtensionName[] = "v8/NetBenchmarking";
  19
  20 namespace extensions_v8 {
  21
  22 class NetBenchmarkingWrapper : public v8::Extension {
  23  public:
  24   NetBenchmarkingWrapper() :
  25       v8::Extension(kNetBenchmarkingExtensionName,
  26         "if (typeof(chrome) == 'undefined') {"
  27         "  chrome = {};"
  28         "};"
  29         "if (typeof(chrome.benchmarking) == 'undefined') {"
  30         "  chrome.benchmarking = {};"
  31         "};"
  32         "chrome.benchmarking.clearCache = function() {"
  33         "  native function ClearCache();"
  34         "  ClearCache();"
  35         "};"
  36         "chrome.benchmarking.clearHostResolverCache = function() {"
  37         "  native function ClearHostResolverCache();"
  38         "  ClearHostResolverCache();"
  39         "};"
  40         "chrome.benchmarking.clearPredictorCache = function() {"
  41         "  native function ClearPredictorCache();"
  42         "  ClearPredictorCache();"
  43         "};"
  44         "chrome.benchmarking.closeConnections = function() {"
  45         "  native function CloseConnections();"
  46         "  CloseConnections();"
  47         "};"
  48         ) {}
  49
  50   v8::Local<v8::FunctionTemplate> GetNativeFunctionTemplate(
  51       v8::Isolate* isolate,
  52       v8::Local<v8::String> name) override {
  53     if (name->StringEquals(
  54             v8::String::NewFromUtf8(isolate, "ClearCache",
  55                                     v8::NewStringType::kInternalized)
  56                 .ToLocalChecked())) {
  57       return v8::FunctionTemplate::New(isolate, ClearCache);
  58     } else if (name->StringEquals(
  59                    v8::String::NewFromUtf8(isolate, "ClearHostResolverCache",
  60                                            v8::NewStringType::kInternalized)
  61                        .ToLocalChecked())) {
  62       return v8::FunctionTemplate::New(isolate, ClearHostResolverCache);
  63     } else if (name->StringEquals(
  64                    v8::String::NewFromUtf8(isolate, "ClearPredictorCache",
  65                                            v8::NewStringType::kInternalized)
  66                        .ToLocalChecked())) {
  67       return v8::FunctionTemplate::New(isolate, ClearPredictorCache);
  68     } else if (name->StringEquals(
  69                    v8::String::NewFromUtf8(isolate, "CloseConnections",
  70                                            v8::NewStringType::kInternalized)
  71                        .ToLocalChecked())) {
  72       return v8::FunctionTemplate::New(isolate, CloseConnections);
  73     }
  74
  75     return v8::Local<v8::FunctionTemplate>();
  76   }
  77
  78   static chrome::mojom::NetBenchmarking& GetNetBenchmarking() {
  79     static base::NoDestructor<mojo::Remote<chrome::mojom::NetBenchmarking>>
  80         net_benchmarking(ConnectToBrowser());
  81     return **net_benchmarking;
  82   }
  83
  84   static mojo::Remote<chrome::mojom::NetBenchmarking> ConnectToBrowser() {
  85     mojo::Remote<chrome::mojom::NetBenchmarking> net_benchmarking;
  86     content::RenderThread::Get()->BindHostReceiver(
  87         net_benchmarking.BindNewPipeAndPassReceiver());
  88     return net_benchmarking;
  89   }
  90
  91   static void ClearCache(const v8::FunctionCallbackInfo<v8::Value>& args) {
  92     GetNetBenchmarking().ClearCache();
  93     WebCache::Clear();
  94   }
  95
  96   static void ClearHostResolverCache(
  97       const v8::FunctionCallbackInfo<v8::Value>& args) {
  98     GetNetBenchmarking().ClearHostResolverCache();
  99   }
 100
 101   static void ClearPredictorCache(
 102       const v8::FunctionCallbackInfo<v8::Value>& args) {
 103     GetNetBenchmarking().ClearPredictorCache();
 104   }
 105
 106   static void CloseConnections(
 107       const v8::FunctionCallbackInfo<v8::Value>& args) {
 108     GetNetBenchmarking().CloseCurrentConnections();
 109   }
 110 };
 111
 112 std::unique_ptr<v8::Extension> NetBenchmarkingExtension::Get() {
 113   return std::make_unique<NetBenchmarkingWrapper>();
 114 }
 115
 116 }  // namespace extensions_v8