bindings: Renames from/toInternalPointer, etc.

Source/bindings/core/v8/custom/V8InjectedScriptHostCustom.cpp

 /*
  * Copyright (C) 2007-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 51 matching lines @@
 #include "core/inspector/JavaScriptCallFrame.h"
 #include "platform/JSONValues.h"
 
 namespace blink {
 
 Node* InjectedScriptHost::scriptValueAsNode(ScriptState* scriptState, ScriptValue value)
 {
     ScriptState::Scope scope(scriptState);
     if (!value.isObject() || value.isNull())
         return 0;
-    return V8Node::toNative(v8::Handle<v8::Object>::Cast(value.v8Value()));
+    return V8Node::toImpl(v8::Handle<v8::Object>::Cast(value.v8Value()));
 }
 
 ScriptValue InjectedScriptHost::nodeAsScriptValue(ScriptState* scriptState, Node* node)
 {
     ScriptState::Scope scope(scriptState);
     v8::Isolate* isolate = scriptState->isolate();
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "nodeAsScriptValue", "InjectedScriptHost", scriptState->context()->Global(), isolate);
     if (!BindingSecurity::shouldAllowAccessToNode(isolate, node, exceptionState))
         return ScriptValue(scriptState, v8::Null(isolate));
     return ScriptValue(scriptState, toV8(node, scriptState->context()->Global(), isolate));
 }
 
 void V8InjectedScriptHost::inspectedObjectMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
 
     if (!info[0]->IsInt32()) {
         V8ThrowException::throwTypeError("argument has to be an integer", info.GetIsolate());
         return;
     }
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     InjectedScriptHost::InspectableObject* object = host->inspectedObject(info[0]->ToInt32()->Value());
     v8SetReturnValue(info, object->get(ScriptState::current(info.GetIsolate())).v8Value());
 }
 
 static v8::Handle<v8::String> functionDisplayName(v8::Handle<v8::Function> function)
 {
     v8::Handle<v8::Value> value = function->GetDisplayName();
     if (value->IsString() && v8::Handle<v8::String>::Cast(value)->Length())
         return v8::Handle<v8::String>::Cast(value);
 
@@ skipping 99 matching lines @@
     location->Set(v8AtomicString(isolate, "lineNumber"), v8::Integer::New(isolate, lineNumber));
     location->Set(v8AtomicString(isolate, "columnNumber"), v8::Integer::New(isolate, columnNumber));
     location->Set(v8AtomicString(isolate, "scriptId"), v8::Integer::New(isolate, function->ScriptId())->ToString());
 
     v8::Local<v8::Object> result = v8::Object::New(isolate);
     result->Set(v8AtomicString(isolate, "location"), location);
 
     v8::Handle<v8::String> name = functionDisplayName(function);
     result->Set(v8AtomicString(isolate, "functionName"), name.IsEmpty() ? v8AtomicString(isolate, "") : name);
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     ScriptDebugServer& debugServer = host->scriptDebugServer();
     v8::Handle<v8::Value> scopes = debugServer.functionScopes(function);
     if (!scopes.IsEmpty() && scopes->IsArray())
         result->Set(v8AtomicString(isolate, "rawScopes"), scopes);
 
     v8SetReturnValue(info, result);
 }
 
 void V8InjectedScriptHost::collectionEntriesMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsObject())
         return;
 
     v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(info[0]);
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     ScriptDebugServer& debugServer = host->scriptDebugServer();
     v8SetReturnValue(info, debugServer.collectionEntries(object));
 }
 
 void V8InjectedScriptHost::getInternalPropertiesMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1 || !info[0]->IsObject())
         return;
 
     v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(info[0]);
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     ScriptDebugServer& debugServer = host->scriptDebugServer();
     v8SetReturnValue(info, debugServer.getInternalProperties(object));
 }
 
 static v8::Handle<v8::Array> getJSListenerFunctions(ExecutionContext* executionContext, const EventListenerInfo& listenerInfo, v8::Isolate* isolate)
 {
     v8::Local<v8::Array> result = v8::Array::New(isolate);
     size_t handlersCount = listenerInfo.eventListenerVector.size();
     for (size_t i = 0, outputIndex = 0; i < handlersCount; ++i) {
         RefPtr<EventListener> listener = listenerInfo.eventListenerVector[i].listener;
@@ skipping 23 matching lines @@
     return result;
 }
 
 void V8InjectedScriptHost::getEventListenersMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
 
 
     v8::Local<v8::Value> value = info[0];
-    EventTarget* target = V8EventTarget::toNativeWithTypeCheck(info.GetIsolate(), value);
+    EventTarget* target = V8EventTarget::toImplWithTypeCheck(info.GetIsolate(), value);
 
     // We need to handle a LocalDOMWindow specially, because a LocalDOMWindow wrapper exists on a prototype chain.
     if (!target)
         target = toDOMWindow(value, info.GetIsolate());
 
     if (!target || !target->executionContext())
         return;
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     Vector<EventListenerInfo> listenersArray;
     host->getEventListenersImpl(target, listenersArray);
 
     v8::Local<v8::Object> result = v8::Object::New(info.GetIsolate());
     for (size_t i = 0; i < listenersArray.size(); ++i) {
         v8::Handle<v8::Array> listeners = getJSListenerFunctions(target->executionContext(), listenersArray[i], info.GetIsolate());
         if (!listeners->Length())
             continue;
         AtomicString eventType = listenersArray[i].eventType;
         result->Set(v8String(info.GetIsolate(), eventType), listeners);
     }
 
     v8SetReturnValue(info, result);
 }
 
 void V8InjectedScriptHost::inspectMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 2)
         return;
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     ScriptState* scriptState = ScriptState::current(info.GetIsolate());
     ScriptValue object(scriptState, info[0]);
     ScriptValue hints(scriptState, info[1]);
     host->inspectImpl(object.toJSONValue(scriptState), hints.toJSONValue(scriptState));
 }
 
 void V8InjectedScriptHost::evalMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Isolate* isolate = info.GetIsolate();
     if (info.Length() < 1) {
@@ skipping 46 matching lines @@
     v8SetReturnValue(info, wrappedResult);
 }
 
 void V8InjectedScriptHost::setFunctionVariableValueMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Handle<v8::Value> functionValue = info[0];
     int scopeIndex = info[1]->Int32Value();
     String variableName = toCoreStringWithUndefinedOrNullCheck(info[2]);
     v8::Handle<v8::Value> newValue = info[3];
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     ScriptDebugServer& debugServer = host->scriptDebugServer();
     v8SetReturnValue(info, debugServer.setFunctionVariableValue(functionValue, scopeIndex, variableName, newValue));
 }
 
 static bool getFunctionLocation(const v8::FunctionCallbackInfo<v8::Value>& info, String* scriptId, int* lineNumber, int* columnNumber)
 {
     if (info.Length() < 1)
         return false;
     v8::Handle<v8::Value> fn = info[0];
     if (!fn->IsFunction())
         return false;
     v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(fn);
     *lineNumber = function->GetScriptLineNumber();
     *columnNumber = function->GetScriptColumnNumber();
     if (*lineNumber == v8::Function::kLineOffsetNotFound || *columnNumber == v8::Function::kLineOffsetNotFound)
         return false;
     *scriptId = String::number(function->ScriptId());
     return true;
 }
 
 void V8InjectedScriptHost::debugFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->debugFunction(scriptId, lineNumber, columnNumber);
 }
 
 void V8InjectedScriptHost::undebugFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->undebugFunction(scriptId, lineNumber, columnNumber);
 }
 
 void V8InjectedScriptHost::monitorFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
     v8::Handle<v8::Value> name;
     if (info.Length() > 0 && info[0]->IsFunction()) {
         v8::Handle<v8::Function> function = v8::Handle<v8::Function>::Cast(info[0]);
         name = function->GetName();
         if (!name->IsString() || !v8::Handle<v8::String>::Cast(name)->Length())
             name = function->GetInferredName();
     }
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->monitorFunction(scriptId, lineNumber, columnNumber, toCoreStringWithUndefinedOrNullCheck(name));
 }
 
 void V8InjectedScriptHost::unmonitorFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     String scriptId;
     int lineNumber;
     int columnNumber;
     if (!getFunctionLocation(info, &scriptId, &lineNumber, &columnNumber))
         return;
 
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     host->unmonitorFunction(scriptId, lineNumber, columnNumber);
 }
 
 void V8InjectedScriptHost::callFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 2 || info.Length() > 3 || !info[0]->IsFunction()) {
         ASSERT_NOT_REACHED();
         return;
     }
 
@@ skipping 16 matching lines @@
     OwnPtr<v8::Handle<v8::Value>[]> argv = adoptArrayPtr(new v8::Handle<v8::Value>[argc]);
     for (size_t i = 0; i < argc; ++i)
         argv[i] = arguments->Get(i);
 
     v8::Local<v8::Value> result = function->Call(receiver, argc, argv.get());
     v8SetReturnValue(info, result);
 }
 
 void V8InjectedScriptHost::suppressWarningsAndCallFunctionMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
-    InjectedScriptHost* host = V8InjectedScriptHost::toNative(info.Holder());
+    InjectedScriptHost* host = V8InjectedScriptHost::toImpl(info.Holder());
     ScriptDebugServer& debugServer = host->scriptDebugServer();
     debugServer.muteWarningsAndDeprecations();
 
     callFunctionMethodCustom(info);
 
     debugServer.unmuteWarningsAndDeprecations();
 }
 
 } // namespace blink