git.sesse.net Git - casparcg/blob - dependencies64/cef/linux/tests/cefclient/renderer/performance_test.cc

   1 // Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights
   2 // reserved. Use of this source code is governed by a BSD-style license that
   3 // can be found in the LICENSE file.
   4
   5 #include "tests/cefclient/renderer/performance_test.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9
  10 #include "include/base/cef_logging.h"
  11 #include "include/wrapper/cef_stream_resource_handler.h"
  12 #include "tests/cefclient/renderer/performance_test_setup.h"
  13
  14 namespace client {
  15 namespace performance_test {
  16
  17 // Use more interations for a Release build.
  18 #if DCHECK_IS_ON()
  19 const int kDefaultIterations = 100000;
  20 #else
  21 const int kDefaultIterations = 10000;
  22 #endif
  23
  24 namespace {
  25
  26 const char kGetPerfTests[] = "GetPerfTests";
  27 const char kRunPerfTest[] = "RunPerfTest";
  28 const char kPerfTestReturnValue[] = "PerfTestReturnValue";
  29
  30 class V8Handler : public CefV8Handler {
  31  public:
  32   V8Handler() {
  33   }
  34
  35   virtual bool Execute(const CefString& name,
  36                        CefRefPtr<CefV8Value> object,
  37                        const CefV8ValueList& arguments,
  38                        CefRefPtr<CefV8Value>& retval,
  39                        CefString& exception) OVERRIDE {
  40     if (name == kRunPerfTest) {
  41       if (arguments.size() == 1 && arguments[0]->IsString()) {
  42         // Run the specified perf test.
  43         bool found = false;
  44
  45         std::string test = arguments[0]->GetStringValue();
  46         for (int i = 0; i < kPerfTestsCount; ++i) {
  47           if (test == kPerfTests[i].name) {
  48             // Execute the test.
  49             int64 delta = kPerfTests[i].test(kPerfTests[i].iterations);
  50
  51             retval = CefV8Value::CreateInt(delta);
  52             found = true;
  53             break;
  54           }
  55         }
  56
  57         if (!found) {
  58           std::string msg = "Unknown test: ";
  59           msg.append(test);
  60           exception = msg;
  61         }
  62       } else {
  63         exception = "Invalid function parameters";
  64       }
  65     } else if (name == kGetPerfTests) {
  66       // Retrieve the list of perf tests.
  67       retval = CefV8Value::CreateArray(kPerfTestsCount);
  68       for (int i = 0; i < kPerfTestsCount; ++i) {
  69         CefRefPtr<CefV8Value> val = CefV8Value::CreateArray(2);
  70         val->SetValue(0, CefV8Value::CreateString(kPerfTests[i].name));
  71         val->SetValue(1, CefV8Value::CreateUInt(kPerfTests[i].iterations));
  72         retval->SetValue(i, val);
  73       }
  74     } else if (name == kPerfTestReturnValue) {
  75       if (arguments.size() == 0) {
  76         retval = CefV8Value::CreateInt(1);
  77       } else if (arguments.size() == 1 && arguments[0]->IsInt()) {
  78         int32 type = arguments[0]->GetIntValue();
  79         CefTime date;
  80         switch (type) {
  81           case 0:
  82             retval = CefV8Value::CreateUndefined();
  83             break;
  84           case 1:
  85             retval = CefV8Value::CreateNull();
  86             break;
  87           case 2:
  88             retval = CefV8Value::CreateBool(true);
  89             break;
  90           case 3:
  91             retval = CefV8Value::CreateInt(1);
  92             break;
  93           case 4:
  94             retval = CefV8Value::CreateUInt(1);
  95             break;
  96           case 5:
  97             retval = CefV8Value::CreateDouble(1.234);
  98             break;
  99           case 6:
 100             date.Now();
 101             retval = CefV8Value::CreateDate(date);
 102             break;
 103           case 7:
 104             retval = CefV8Value::CreateString("Hello, world!");
 105             break;
 106           case 8:
 107             retval = CefV8Value::CreateObject(NULL, NULL);
 108             break;
 109           case 9:
 110             retval = CefV8Value::CreateArray(8);
 111             break;
 112           case 10:
 113             // retval = CefV8Value::CreateFunction(...);
 114             exception = "Not implemented";
 115             break;
 116           default:
 117             exception = "Not supported";
 118         }
 119       }
 120     }
 121
 122     return true;
 123   }
 124
 125  private:
 126   IMPLEMENT_REFCOUNTING(V8Handler);
 127 };
 128
 129 // Handle bindings in the render process.
 130 class RenderDelegate : public ClientAppRenderer::Delegate {
 131  public:
 132   RenderDelegate() {
 133   }
 134
 135   virtual void OnContextCreated(CefRefPtr<ClientAppRenderer> app,
 136                                 CefRefPtr<CefBrowser> browser,
 137                                 CefRefPtr<CefFrame> frame,
 138                                 CefRefPtr<CefV8Context> context) OVERRIDE {
 139     CefRefPtr<CefV8Value> object = context->GetGlobal();
 140
 141     CefRefPtr<CefV8Handler> handler = new V8Handler();
 142
 143     // Bind test functions.
 144     object->SetValue(kGetPerfTests,
 145         CefV8Value::CreateFunction(kGetPerfTests, handler),
 146             V8_PROPERTY_ATTRIBUTE_READONLY);
 147     object->SetValue(kRunPerfTest,
 148         CefV8Value::CreateFunction(kRunPerfTest, handler),
 149             V8_PROPERTY_ATTRIBUTE_READONLY);
 150     object->SetValue(kPerfTestReturnValue,
 151         CefV8Value::CreateFunction(kPerfTestReturnValue, handler),
 152             V8_PROPERTY_ATTRIBUTE_READONLY);
 153   }
 154
 155  private:
 156   IMPLEMENT_REFCOUNTING(RenderDelegate);
 157 };
 158
 159 }  // namespace
 160
 161 void CreateDelegates(ClientAppRenderer::DelegateSet& delegates) {
 162   delegates.insert(new RenderDelegate);
 163 }
 164
 165 }  // namespace performance_test
 166 }  // namespace client