Title: [185722] trunk/Source
Revision
185722
Author
[email protected]
Date
2015-06-18 15:07:15 -0700 (Thu, 18 Jun 2015)

Log Message

Web Inspector: improve generated types for objects passed to backend commands
https://bugs.webkit.org/show_bug.cgi?id=146091

Patch by Brian J. Burg <[email protected]> on 2015-06-18
Reviewed by Joseph Pecoraro.

Source/_javascript_Core:

The main change is that objects passed in will have a type like const T& or const T*,
rather than const RefPtr<T>&&. These protocol objects are owned by the generated dispatcher
methods and only exist to pass data to backend command implementations. So, there is no
reason for callees to add a reference or take ownership of these inputs.

Some small improvements were made in the code generator to standardize how these
expressions are generated for parameters. Optional in parameters are now prefixed with
'opt_in_' to make the generated method signatures and implementations clearer.

* inspector/InspectorValues.cpp:
(Inspector::InspectorArrayBase::get): Add const qualifier.
* inspector/InspectorValues.h:
* inspector/agents/InspectorDebuggerAgent.cpp:
(Inspector::InspectorDebuggerAgent::setBreakpointByUrl):
(Inspector::parseLocation):
(Inspector::InspectorDebuggerAgent::setBreakpoint):
(Inspector::InspectorDebuggerAgent::continueToLocation):
* inspector/agents/InspectorDebuggerAgent.h:
* inspector/agents/InspectorRuntimeAgent.cpp:
(Inspector::InspectorRuntimeAgent::callFunctionOn):
(Inspector::InspectorRuntimeAgent::saveResult):
(Inspector::InspectorRuntimeAgent::getRuntimeTypesForVariablesAtOffsets):
* inspector/agents/InspectorRuntimeAgent.h:

* inspector/scripts/codegen/cpp_generator.py: Always generate PrimitiveType('array').
(CppGenerator.cpp_type_for_unchecked_formal_in_parameter): Alter the type signature
for an unchecked input to use pointers or references.

* inspector/scripts/codegen/generate_cpp_backend_dispatcher_header.py:
(CppBackendDispatcherHeaderGenerator._generate_handler_declaration_for_command):
(CppBackendDispatcherHeaderGenerator._generate_async_handler_declaration_for_command):
Local variables for optional parameters now have the 'opt_' prefix.

* inspector/scripts/codegen/generate_cpp_backend_dispatcher_implementation.py:
(CppBackendDispatcherImplementationGenerator._generate_async_dispatcher_class_for_domain):
(CppBackendDispatcherImplementationGenerator._generate_dispatcher_implementation_for_command):
Local variables for optional parameters now have the 'opt_' prefix.
Split parameterName and parameterKey into two separate template variables to avoid mixups.

* inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result:

Source/WebCore:

Update type signatures for backend command implementations. In a few cases, clean
up relevant helper function signatures and copy data out of parameter objects where
the code previously held onto a reference.

No new tests, no behavior changed.

* inspector/InspectorCSSAgent.cpp:
(WebCore::computePseudoClassMask):
(WebCore::InspectorCSSAgent::setStyleText):
(WebCore::InspectorCSSAgent::setRuleSelector):
(WebCore::InspectorCSSAgent::forcePseudoState):
* inspector/InspectorCSSAgent.h:
* inspector/InspectorDOMAgent.cpp:
(WebCore::parseColor):
(WebCore::parseConfigColor):
(WebCore::parseQuad):
(WebCore::InspectorDOMAgent::performSearch):
(WebCore::InspectorDOMAgent::setSearchingForNode):
(WebCore::InspectorDOMAgent::highlightConfigFromInspectorObject):
(WebCore::InspectorDOMAgent::setInspectModeEnabled):
(WebCore::InspectorDOMAgent::highlightRect):
(WebCore::InspectorDOMAgent::highlightQuad):
(WebCore::InspectorDOMAgent::innerHighlightQuad):
(WebCore::InspectorDOMAgent::highlightNode):
(WebCore::InspectorDOMAgent::highlightFrame):
* inspector/InspectorDOMAgent.h:
* inspector/InspectorDOMStorageAgent.cpp:
(WebCore::InspectorDOMStorageAgent::getDOMStorageItems):
(WebCore::InspectorDOMStorageAgent::setDOMStorageItem):
(WebCore::InspectorDOMStorageAgent::removeDOMStorageItem):
(WebCore::InspectorDOMStorageAgent::findStorageArea):
* inspector/InspectorDOMStorageAgent.h:
* inspector/InspectorIndexedDBAgent.cpp:
(WebCore::InspectorIndexedDBAgent::requestData):
* inspector/InspectorIndexedDBAgent.h:
* inspector/InspectorReplayAgent.cpp:
(WebCore::InspectorReplayAgent::replayToPosition):
* inspector/InspectorReplayAgent.h:
* inspector/InspectorResourceAgent.cpp:
(WebCore::InspectorResourceAgent::willSendRequest):
(WebCore::InspectorResourceAgent::setExtraHTTPHeaders):
Clean up extraHTTPHeaders to copy header key/values out of the InspectorObject, rather
than retaining the protocol object indefinitely. This matches the ownership scheme used
everywhere else.

* inspector/InspectorResourceAgent.h:
* inspector/InspectorStyleSheet.h:
(WebCore::InspectorCSSId::InspectorCSSId):
* inspector/InspectorWorkerAgent.cpp:
(WebCore::InspectorWorkerAgent::sendMessageToWorker):
* inspector/InspectorWorkerAgent.h:

Modified Paths

Diff

Modified: trunk/Source/_javascript_Core/ChangeLog (185721 => 185722)


--- trunk/Source/_javascript_Core/ChangeLog	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/ChangeLog	2015-06-18 22:07:15 UTC (rev 185722)
@@ -1,3 +1,51 @@
+2015-06-18  Brian J. Burg  <[email protected]>
+
+        Web Inspector: improve generated types for objects passed to backend commands
+        https://bugs.webkit.org/show_bug.cgi?id=146091
+
+        Reviewed by Joseph Pecoraro.
+
+        The main change is that objects passed in will have a type like const T& or const T*,
+        rather than const RefPtr<T>&&. These protocol objects are owned by the generated dispatcher
+        methods and only exist to pass data to backend command implementations. So, there is no
+        reason for callees to add a reference or take ownership of these inputs.
+
+        Some small improvements were made in the code generator to standardize how these
+        expressions are generated for parameters. Optional in parameters are now prefixed with
+        'opt_in_' to make the generated method signatures and implementations clearer.
+
+        * inspector/InspectorValues.cpp:
+        (Inspector::InspectorArrayBase::get): Add const qualifier.
+        * inspector/InspectorValues.h:
+        * inspector/agents/InspectorDebuggerAgent.cpp:
+        (Inspector::InspectorDebuggerAgent::setBreakpointByUrl):
+        (Inspector::parseLocation):
+        (Inspector::InspectorDebuggerAgent::setBreakpoint):
+        (Inspector::InspectorDebuggerAgent::continueToLocation):
+        * inspector/agents/InspectorDebuggerAgent.h:
+        * inspector/agents/InspectorRuntimeAgent.cpp:
+        (Inspector::InspectorRuntimeAgent::callFunctionOn):
+        (Inspector::InspectorRuntimeAgent::saveResult):
+        (Inspector::InspectorRuntimeAgent::getRuntimeTypesForVariablesAtOffsets):
+        * inspector/agents/InspectorRuntimeAgent.h:
+
+        * inspector/scripts/codegen/cpp_generator.py: Always generate PrimitiveType('array').
+        (CppGenerator.cpp_type_for_unchecked_formal_in_parameter): Alter the type signature
+        for an unchecked input to use pointers or references.
+
+        * inspector/scripts/codegen/generate_cpp_backend_dispatcher_header.py:
+        (CppBackendDispatcherHeaderGenerator._generate_handler_declaration_for_command):
+        (CppBackendDispatcherHeaderGenerator._generate_async_handler_declaration_for_command):
+        Local variables for optional parameters now have the 'opt_' prefix.
+
+        * inspector/scripts/codegen/generate_cpp_backend_dispatcher_implementation.py:
+        (CppBackendDispatcherImplementationGenerator._generate_async_dispatcher_class_for_domain):
+        (CppBackendDispatcherImplementationGenerator._generate_dispatcher_implementation_for_command):
+        Local variables for optional parameters now have the 'opt_' prefix.
+        Split parameterName and parameterKey into two separate template variables to avoid mixups.
+
+        * inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result:
+
 2015-06-18  Joseph Pecoraro  <[email protected]>
 
         Unreviewed. Rollout r185670 as it caused some tests to be flakey.

Modified: trunk/Source/_javascript_Core/inspector/InspectorValues.cpp (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/InspectorValues.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/InspectorValues.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -839,7 +839,7 @@
 {
 }
 
-RefPtr<InspectorValue> InspectorArrayBase::get(size_t index)
+RefPtr<InspectorValue> InspectorArrayBase::get(size_t index) const
 {
     ASSERT_WITH_SECURITY_IMPLICATION(index < m_data.size());
     return m_data[index];

Modified: trunk/Source/_javascript_Core/inspector/InspectorValues.h (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/InspectorValues.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/InspectorValues.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -279,7 +279,7 @@
     void pushObject(RefPtr<InspectorObjectBase>&&);
     void pushArray(RefPtr<InspectorArrayBase>&&);
 
-    RefPtr<InspectorValue> get(size_t index);
+    RefPtr<InspectorValue> get(size_t index) const;
 
     virtual void writeJSON(StringBuilder& output) const override;
 

Modified: trunk/Source/_javascript_Core/inspector/agents/InspectorDebuggerAgent.cpp (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/agents/InspectorDebuggerAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/agents/InspectorDebuggerAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -275,7 +275,7 @@
     return true;
 }
 
-void InspectorDebuggerAgent::setBreakpointByUrl(ErrorString& errorString, int lineNumber, const String* const optionalURL, const String* const optionalURLRegex, const int* const optionalColumnNumber, const RefPtr<InspectorObject>&& options, Inspector::Protocol::Debugger::BreakpointId* outBreakpointIdentifier, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Debugger::Location>>& locations)
+void InspectorDebuggerAgent::setBreakpointByUrl(ErrorString& errorString, int lineNumber, const String* const optionalURL, const String* const optionalURLRegex, const int* const optionalColumnNumber, const InspectorObject* options, Inspector::Protocol::Debugger::BreakpointId* outBreakpointIdentifier, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Debugger::Location>>& locations)
 {
     locations = Inspector::Protocol::Array<Inspector::Protocol::Debugger::Location>::create();
     if (!optionalURL == !optionalURLRegex) {
@@ -321,7 +321,7 @@
     *outBreakpointIdentifier = breakpointIdentifier;
 }
 
-static bool parseLocation(ErrorString& errorString, InspectorObject& location, JSC::SourceID& sourceID, unsigned& lineNumber, unsigned& columnNumber)
+static bool parseLocation(ErrorString& errorString, const InspectorObject& location, JSC::SourceID& sourceID, unsigned& lineNumber, unsigned& columnNumber)
 {
     String scriptIDStr;
     if (!location.getString(ASCIILiteral("scriptId"), scriptIDStr) || !location.getInteger(ASCIILiteral("lineNumber"), lineNumber)) {
@@ -336,12 +336,12 @@
     return true;
 }
 
-void InspectorDebuggerAgent::setBreakpoint(ErrorString& errorString, const RefPtr<InspectorObject>&& location, const RefPtr<InspectorObject>&& options, Inspector::Protocol::Debugger::BreakpointId* outBreakpointIdentifier, RefPtr<Inspector::Protocol::Debugger::Location>& actualLocation)
+void InspectorDebuggerAgent::setBreakpoint(ErrorString& errorString, const InspectorObject& location, const InspectorObject* options, Inspector::Protocol::Debugger::BreakpointId* outBreakpointIdentifier, RefPtr<Inspector::Protocol::Debugger::Location>& actualLocation)
 {
     JSC::SourceID sourceID;
     unsigned lineNumber;
     unsigned columnNumber;
-    if (!parseLocation(errorString, *location, sourceID, lineNumber, columnNumber))
+    if (!parseLocation(errorString, location, sourceID, lineNumber, columnNumber))
         return;
 
     String condition = emptyString();
@@ -388,7 +388,7 @@
     }
 }
 
-void InspectorDebuggerAgent::continueToLocation(ErrorString& errorString, const RefPtr<InspectorObject>&& location)
+void InspectorDebuggerAgent::continueToLocation(ErrorString& errorString, const InspectorObject& location)
 {
     if (m_continueToLocationBreakpointID != JSC::noBreakpointID) {
         scriptDebugServer().removeBreakpoint(m_continueToLocationBreakpointID);
@@ -398,7 +398,7 @@
     JSC::SourceID sourceID;
     unsigned lineNumber;
     unsigned columnNumber;
-    if (!parseLocation(errorString, *location, sourceID, lineNumber, columnNumber))
+    if (!parseLocation(errorString, location, sourceID, lineNumber, columnNumber))
         return;
 
     ScriptBreakpoint breakpoint(lineNumber, columnNumber, "", false);

Modified: trunk/Source/_javascript_Core/inspector/agents/InspectorDebuggerAgent.h (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/agents/InspectorDebuggerAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/agents/InspectorDebuggerAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -71,10 +71,10 @@
     virtual void enable(ErrorString&) override;
     virtual void disable(ErrorString&) override;
     virtual void setBreakpointsActive(ErrorString&, bool active) override;
-    virtual void setBreakpointByUrl(ErrorString&, int lineNumber, const String* optionalURL, const String* optionalURLRegex, const int* optionalColumnNumber, const RefPtr<Inspector::InspectorObject>&& options, Inspector::Protocol::Debugger::BreakpointId*, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Debugger::Location>>& locations) override;
-    virtual void setBreakpoint(ErrorString&, const RefPtr<Inspector::InspectorObject>&& location, const RefPtr<Inspector::InspectorObject>&& options, Inspector::Protocol::Debugger::BreakpointId*, RefPtr<Inspector::Protocol::Debugger::Location>& actualLocation) override;
+    virtual void setBreakpointByUrl(ErrorString&, int lineNumber, const String* optionalURL, const String* optionalURLRegex, const int* optionalColumnNumber, const Inspector::InspectorObject* options, Inspector::Protocol::Debugger::BreakpointId*, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Debugger::Location>>& locations) override;
+    virtual void setBreakpoint(ErrorString&, const Inspector::InspectorObject& location, const Inspector::InspectorObject* options, Inspector::Protocol::Debugger::BreakpointId*, RefPtr<Inspector::Protocol::Debugger::Location>& actualLocation) override;
     virtual void removeBreakpoint(ErrorString&, const String& breakpointIdentifier) override;
-    virtual void continueToLocation(ErrorString&, const RefPtr<InspectorObject>&& location) override;
+    virtual void continueToLocation(ErrorString&, const InspectorObject& location) override;
     virtual void searchInContent(ErrorString&, const String& scriptID, const String& query, const bool* optionalCaseSensitive, const bool* optionalIsRegex, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::GenericTypes::SearchMatch>>&) override;
     virtual void getScriptSource(ErrorString&, const String& scriptID, String* scriptSource) override;
     virtual void getFunctionDetails(ErrorString&, const String& functionId, RefPtr<Inspector::Protocol::Debugger::FunctionDetails>&) override;

Modified: trunk/Source/_javascript_Core/inspector/agents/InspectorRuntimeAgent.cpp (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/agents/InspectorRuntimeAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/agents/InspectorRuntimeAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -134,7 +134,7 @@
     }
 }
 
-void InspectorRuntimeAgent::callFunctionOn(ErrorString& errorString, const String& objectId, const String& _expression_, const RefPtr<InspectorArray>&& optionalArguments, const bool* const doNotPauseOnExceptionsAndMuteConsole, const bool* const returnByValue, const bool* generatePreview, RefPtr<Inspector::Protocol::Runtime::RemoteObject>& result, Inspector::Protocol::OptOutput<bool>* wasThrown)
+void InspectorRuntimeAgent::callFunctionOn(ErrorString& errorString, const String& objectId, const String& _expression_, const InspectorArray* optionalArguments, const bool* const doNotPauseOnExceptionsAndMuteConsole, const bool* const returnByValue, const bool* generatePreview, RefPtr<Inspector::Protocol::Runtime::RemoteObject>& result, Inspector::Protocol::OptOutput<bool>* wasThrown)
 {
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(objectId);
     if (injectedScript.hasNoValue()) {
@@ -210,12 +210,12 @@
     injectedScript.getCollectionEntries(errorString, objectId, objectGroup ? *objectGroup : String(), start, fetch, &entries);
 }
 
-void InspectorRuntimeAgent::saveResult(ErrorString& errorString, const RefPtr<Inspector::InspectorObject>&& callArgument, const int* executionContextId, Inspector::Protocol::OptOutput<int>* savedResultIndex)
+void InspectorRuntimeAgent::saveResult(ErrorString& errorString, const Inspector::InspectorObject& callArgument, const int* executionContextId, Inspector::Protocol::OptOutput<int>* savedResultIndex)
 {
     InjectedScript injectedScript;
 
     String objectId;
-    if (callArgument->getString(ASCIILiteral("objectId"), objectId)) {
+    if (callArgument.getString(ASCIILiteral("objectId"), objectId)) {
         injectedScript = m_injectedScriptManager->injectedScriptForObjectId(objectId);
         if (injectedScript.hasNoValue()) {
             errorString = ASCIILiteral("Inspected frame has gone");
@@ -227,7 +227,7 @@
             return;
     }
 
-    injectedScript.saveResult(errorString, callArgument->toJSONString(), savedResultIndex);
+    injectedScript.saveResult(errorString, callArgument.toJSONString(), savedResultIndex);
 }
 
 void InspectorRuntimeAgent::releaseObject(ErrorString&, const String& objectId)
@@ -247,7 +247,7 @@
     // FIXME: <https://webkit.org/b/127634> Web Inspector: support debugging web workers
 }
 
-void InspectorRuntimeAgent::getRuntimeTypesForVariablesAtOffsets(ErrorString& errorString, const RefPtr<Inspector::InspectorArray>&& locations, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::TypeDescription>>& typeDescriptions)
+void InspectorRuntimeAgent::getRuntimeTypesForVariablesAtOffsets(ErrorString& errorString, const Inspector::InspectorArray& locations, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::TypeDescription>>& typeDescriptions)
 {
     static const bool verbose = false;
     VM& vm = globalVM();
@@ -260,8 +260,8 @@
     double start = currentTimeMS();
     vm.typeProfilerLog()->processLogEntries(ASCIILiteral("User Query"));
 
-    for (size_t i = 0; i < locations->length(); i++) {
-        RefPtr<Inspector::InspectorValue> value = locations->get(i);
+    for (size_t i = 0; i < locations.length(); i++) {
+        RefPtr<Inspector::InspectorValue> value = locations.get(i);
         RefPtr<InspectorObject> location;
         if (!value->asObject(location)) {
             errorString = ASCIILiteral("Array of TypeLocation objects has an object that does not have type of TypeLocation.");

Modified: trunk/Source/_javascript_Core/inspector/agents/InspectorRuntimeAgent.h (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/agents/InspectorRuntimeAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/agents/InspectorRuntimeAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -61,15 +61,15 @@
     virtual void disable(ErrorString&) override { m_enabled = false; }
     virtual void parse(ErrorString&, const String& _expression_, Inspector::Protocol::Runtime::SyntaxErrorType* result, Inspector::Protocol::OptOutput<String>* message, RefPtr<Inspector::Protocol::Runtime::ErrorRange>&) override final;
     virtual void evaluate(ErrorString&, const String& _expression_, const String* objectGroup, const bool* includeCommandLineAPI, const bool* doNotPauseOnExceptionsAndMuteConsole, const int* executionContextId, const bool* returnByValue, const bool* generatePreview, const bool* saveResult, RefPtr<Inspector::Protocol::Runtime::RemoteObject>& result, Inspector::Protocol::OptOutput<bool>* wasThrown, Inspector::Protocol::OptOutput<int>* savedResultIndex) override final;
-    virtual void callFunctionOn(ErrorString&, const String& objectId, const String& _expression_, const RefPtr<Inspector::InspectorArray>&& optionalArguments, const bool* doNotPauseOnExceptionsAndMuteConsole, const bool* returnByValue, const bool* generatePreview, RefPtr<Inspector::Protocol::Runtime::RemoteObject>& result, Inspector::Protocol::OptOutput<bool>* wasThrown) override final;
+    virtual void callFunctionOn(ErrorString&, const String& objectId, const String& _expression_, const Inspector::InspectorArray* optionalArguments, const bool* doNotPauseOnExceptionsAndMuteConsole, const bool* returnByValue, const bool* generatePreview, RefPtr<Inspector::Protocol::Runtime::RemoteObject>& result, Inspector::Protocol::OptOutput<bool>* wasThrown) override final;
     virtual void releaseObject(ErrorString&, const ErrorString& objectId) override final;
     virtual void getProperties(ErrorString&, const String& objectId, const bool* ownProperties, const bool* generatePreview, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::PropertyDescriptor>>& result, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::InternalPropertyDescriptor>>& internalProperties) override final;
     virtual void getDisplayableProperties(ErrorString&, const String& objectId, const bool* generatePreview, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::PropertyDescriptor>>& result, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::InternalPropertyDescriptor>>& internalProperties) override final;
     virtual void getCollectionEntries(ErrorString&, const String& objectId, const String* objectGroup, const int* startIndex, const int* numberToFetch, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::CollectionEntry>>& entries) override final;
-    virtual void saveResult(ErrorString&, const RefPtr<Inspector::InspectorObject>&& callArgument, const int* executionContextId, Inspector::Protocol::OptOutput<int>* savedResultIndex) override final;
+    virtual void saveResult(ErrorString&, const Inspector::InspectorObject& callArgument, const int* executionContextId, Inspector::Protocol::OptOutput<int>* savedResultIndex) override final;
     virtual void releaseObjectGroup(ErrorString&, const String& objectGroup) override final;
     virtual void run(ErrorString&) override;
-    virtual void getRuntimeTypesForVariablesAtOffsets(ErrorString&, const RefPtr<Inspector::InspectorArray>&& locations, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::TypeDescription>>&) override;
+    virtual void getRuntimeTypesForVariablesAtOffsets(ErrorString&, const Inspector::InspectorArray& locations, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::TypeDescription>>&) override;
     virtual void enableTypeProfiler(ErrorString&) override;
     virtual void disableTypeProfiler(ErrorString&) override;
     virtual void getBasicBlocks(ErrorString&, const String& in_sourceID, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Runtime::BasicBlock>>& out_basicBlocks) override;

Modified: trunk/Source/_javascript_Core/inspector/scripts/codegen/cpp_generator.py (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/scripts/codegen/cpp_generator.py	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/scripts/codegen/cpp_generator.py	2015-06-18 22:07:15 UTC (rev 185722)
@@ -39,6 +39,7 @@
     'number': 'double',
     'string': 'String',
     'object': 'Inspector::InspectorObject',
+    'array': 'Inspector::InspectorArray',
     'any': 'Inspector::InspectorValue'
 }
 
@@ -119,9 +120,17 @@
 
         # This handles the 'any' type and objects with defined properties.
         if isinstance(_type, ObjectType) or _type.qualified_name() is 'object':
-            return 'const RefPtr<Inspector::InspectorObject>&&'
+            cpp_name = 'Inspector::InspectorObject'
+            if parameter.is_optional:
+                return 'const %s*' % cpp_name
+            else:
+                return 'const %s&' % cpp_name
         if isinstance(_type, ArrayType):
-            return 'const RefPtr<Inspector::InspectorArray>&&'
+            cpp_name = 'Inspector::InspectorArray'
+            if parameter.is_optional:
+                return 'const %s*' % cpp_name
+            else:
+                return 'const %s&' % cpp_name
         if isinstance(_type, PrimitiveType):
             cpp_name = CppGenerator.cpp_name_for_primitive_type(_type)
             if parameter.is_optional:

Modified: trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_cpp_backend_dispatcher_header.py (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_cpp_backend_dispatcher_header.py	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_cpp_backend_dispatcher_header.py	2015-06-18 22:07:15 UTC (rev 185722)
@@ -127,8 +127,12 @@
         lines = []
         parameters = ['ErrorString&']
         for _parameter in command.call_parameters:
-            parameters.append("%s in_%s" % (CppGenerator.cpp_type_for_unchecked_formal_in_parameter(_parameter), _parameter.parameter_name))
+            parameter_name = 'in_' + _parameter.parameter_name
+            if _parameter.is_optional:
+                parameter_name = 'opt_' + parameter_name
 
+            parameters.append("%s %s" % (CppGenerator.cpp_type_for_unchecked_formal_in_parameter(_parameter), parameter_name))
+
             if isinstance(_parameter.type, EnumType) and _parameter.parameter_name not in used_enum_names:
                 lines.append(self._generate_anonymous_enum_for_parameter(_parameter, command))
                 used_enum_names.add(_parameter.parameter_name)
@@ -155,7 +159,11 @@
 
         in_parameters = ['ErrorString&']
         for _parameter in command.call_parameters:
-            in_parameters.append("%s in_%s" % (CppGenerator.cpp_type_for_unchecked_formal_in_parameter(_parameter), _parameter.parameter_name))
+            parameter_name = 'in_' + _parameter.parameter_name
+            if _parameter.is_optional:
+                parameter_name = 'opt_' + parameter_name
+
+            in_parameters.append("%s %s" % (CppGenerator.cpp_type_for_unchecked_formal_in_parameter(_parameter), parameter_name))
         in_parameters.append("Ref<%s>&& callback" % callbackName)
 
         out_parameters = []

Modified: trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_cpp_backend_dispatcher_implementation.py (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_cpp_backend_dispatcher_implementation.py	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_cpp_backend_dispatcher_implementation.py	2015-06-18 22:07:15 UTC (rev 185722)
@@ -139,6 +139,7 @@
         for parameter in command.return_parameters:
             param_args = {
                 'keyedSetMethod': CppGenerator.cpp_setter_method_for_type(parameter.type),
+                'parameterKey': parameter.parameter_name,
                 'parameterName': parameter.parameter_name,
                 'parameterType': CppGenerator.cpp_type_for_stack_in_parameter(parameter),
             }
@@ -148,14 +149,14 @@
             if parameter.is_optional:
                 if CppGenerator.should_use_wrapper_for_return_type(parameter.type):
                     out_parameter_assignments.append('    if (%(parameterName)s.isAssigned())' % param_args)
-                    out_parameter_assignments.append('        jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), %(parameterName)s.getValue());' % param_args)
+                    out_parameter_assignments.append('        jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), %(parameterName)s.getValue());' % param_args)
                 else:
                     out_parameter_assignments.append('    if (%(parameterName)s)' % param_args)
-                    out_parameter_assignments.append('        jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), %(parameterName)s);' % param_args)
+                    out_parameter_assignments.append('        jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), %(parameterName)s);' % param_args)
             elif parameter.type.is_enum():
-                out_parameter_assignments.append('    jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), Inspector::Protocol::getEnumConstantValue(%(parameterName)s));' % param_args)
+                out_parameter_assignments.append('    jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), Inspector::Protocol::getEnumConstantValue(%(parameterName)s));' % param_args)
             else:
-                out_parameter_assignments.append('    jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), %(parameterName)s);' % param_args)
+                out_parameter_assignments.append('    jsonMessage->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), %(parameterName)s);' % param_args)
 
         async_args = {
             'domainName': domain.domain_name,
@@ -173,26 +174,40 @@
         method_parameters = ['error']
 
         for parameter in command.call_parameters:
+            parameter_name = 'in_' + parameter.parameter_name
+            if parameter.is_optional:
+                parameter_name = 'opt_' + parameter_name
+
             out_success_argument = 'nullptr'
             if parameter.is_optional:
-                out_success_argument = '&%s_valueFound' % parameter.parameter_name
-                in_parameter_declarations.append('    bool %s_valueFound = false;' % parameter.parameter_name)
+                out_success_argument = '&%s_valueFound' % parameter_name
+                in_parameter_declarations.append('    bool %s_valueFound = false;' % parameter_name)
 
-            parameter_expression = 'in_' + parameter.parameter_name
+            # Now add appropriate operators.
+            parameter_expression = parameter_name
+
             if CppGenerator.should_use_references_for_type(parameter.type):
-                parameter_expression = '%s.copyRef()' % parameter_expression
+                if parameter.is_optional:
+                    parameter_expression = '%s.get()' % parameter_expression
+                else:
+                    # This assumes that we have already proved the object is non-null.
+                    # If a required property is missing, InspectorBackend::getObject will
+                    # append a protocol error, and the method dispatcher will return without
+                    # invoking the backend method (and dereferencing the object).
+                    parameter_expression = '*%s' % parameter_expression
             elif parameter.is_optional:
                 parameter_expression = '&%s' % parameter_expression
 
             param_args = {
                 'parameterType': CppGenerator.cpp_type_for_stack_in_parameter(parameter),
-                'parameterName': parameter.parameter_name,
+                'parameterKey': parameter.parameter_name,
+                'parameterName': parameter_name,
                 'parameterExpression': parameter_expression,
                 'keyedGetMethod': CppGenerator.cpp_getter_method_for_type(parameter.type),
                 'successOutParam': out_success_argument
             }
 
-            in_parameter_declarations.append('    %(parameterType)s in_%(parameterName)s = BackendDispatcher::%(keyedGetMethod)s(paramsContainer.get(), ASCIILiteral("%(parameterName)s"), %(successOutParam)s, protocolErrors.get());' % param_args)
+            in_parameter_declarations.append('    %(parameterType)s %(parameterName)s = BackendDispatcher::%(keyedGetMethod)s(paramsContainer.get(), ASCIILiteral("%(parameterKey)s"), %(successOutParam)s, protocolErrors.get());' % param_args)
 
             if parameter.is_optional:
                 optional_in_parameter_string = '%(parameterName)s_valueFound ? %(parameterExpression)s : nullptr' % param_args
@@ -217,6 +232,7 @@
             for parameter in command.return_parameters:
                 param_args = {
                     'parameterType': CppGenerator.cpp_type_for_stack_out_parameter(parameter),
+                    'parameterKey': parameter.parameter_name,
                     'parameterName': parameter.parameter_name,
                     'keyedSetMethod': CppGenerator.cpp_setter_method_for_type(parameter.type),
 
@@ -226,14 +242,14 @@
                 if parameter.is_optional:
                     if CppGenerator.should_use_wrapper_for_return_type(parameter.type):
                         out_parameter_assignments.append('        if (out_%(parameterName)s.isAssigned())' % param_args)
-                        out_parameter_assignments.append('            result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s.getValue());' % param_args)
+                        out_parameter_assignments.append('            result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s.getValue());' % param_args)
                     else:
                         out_parameter_assignments.append('        if (out_%(parameterName)s)' % param_args)
-                        out_parameter_assignments.append('            result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s);' % param_args)
+                        out_parameter_assignments.append('            result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s);' % param_args)
                 elif parameter.type.is_enum():
-                    out_parameter_assignments.append('        result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), Inspector::Protocol::getEnumConstantValue(out_%(parameterName)s));' % param_args)
+                    out_parameter_assignments.append('        result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), Inspector::Protocol::getEnumConstantValue(out_%(parameterName)s));' % param_args)
                 else:
-                    out_parameter_assignments.append('        result->%(keyedSetMethod)s(ASCIILiteral("%(parameterName)s"), out_%(parameterName)s);' % param_args)
+                    out_parameter_assignments.append('        result->%(keyedSetMethod)s(ASCIILiteral("%(parameterKey)s"), out_%(parameterName)s);' % param_args)
 
                 if CppGenerator.should_pass_by_copy_for_return_type(parameter.type):
                     method_parameters.append('out_' + parameter.parameter_name)

Modified: trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_objc_backend_dispatcher_implementation.py (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_objc_backend_dispatcher_implementation.py	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/scripts/codegen/generate_objc_backend_dispatcher_implementation.py	2015-06-18 22:07:15 UTC (rev 185722)
@@ -158,8 +158,10 @@
             if isinstance(_type, EnumType):
                 _type = _type.primitive_type  # Fall through to primitive.
             if isinstance(_type, PrimitiveType):
+                if _type.raw_name() in ['array', 'any', 'object']:
+                    return '&%s' % param_name if not parameter.is_optional else param_name
                 return '*%s' % param_name if parameter.is_optional else param_name
-            return '%s.copyRef()' % param_name
+            return '&%s' % param_name if not parameter.is_optional else param_name
 
         for parameter in command.call_parameters:
             in_param_name = 'in_%s' % parameter.parameter_name

Modified: trunk/Source/_javascript_Core/inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result (185721 => 185722)


--- trunk/Source/_javascript_Core/inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/_javascript_Core/inspector/scripts/tests/expected/commands-with-optional-call-return-parameters.json-result	2015-06-18 22:07:15 UTC (rev 185722)
@@ -51,8 +51,8 @@
 class AlternateDatabaseBackendDispatcher : public AlternateBackendDispatcher {
 public:
     virtual ~AlternateDatabaseBackendDispatcher() { }
-    virtual void executeAllOptionalParameters(long callId, const RefPtr<Inspector::InspectorArray>&& in_columnNames, const String* in_notes, const double* in_timestamp, const RefPtr<Inspector::InspectorObject>&& in_values, const Inspector::InspectorValue* in_payload, const int* in_databaseId, const RefPtr<Inspector::InspectorObject>&& in_sqlError, const String* in_screenColor, const RefPtr<Inspector::InspectorArray>&& in_alternateColors, const String* in_printColor) = 0;
-    virtual void executeNoOptionalParameters(long callId, const RefPtr<Inspector::InspectorArray>&& in_columnNames, const String& in_notes, double in_timestamp, const RefPtr<Inspector::InspectorObject>&& in_values, Inspector::InspectorValue in_payload, int in_databaseId, const RefPtr<Inspector::InspectorObject>&& in_sqlError, const String& in_screenColor, const RefPtr<Inspector::InspectorArray>&& in_alternateColors, const String& in_printColor) = 0;
+    virtual void executeAllOptionalParameters(long callId, const Inspector::InspectorArray* in_columnNames, const String* in_notes, const double* in_timestamp, const Inspector::InspectorObject* in_values, const Inspector::InspectorValue* in_payload, const int* in_databaseId, const Inspector::InspectorObject* in_sqlError, const String* in_screenColor, const Inspector::InspectorArray* in_alternateColors, const String* in_printColor) = 0;
+    virtual void executeNoOptionalParameters(long callId, const Inspector::InspectorArray& in_columnNames, const String& in_notes, double in_timestamp, const Inspector::InspectorObject& in_values, Inspector::InspectorValue in_payload, int in_databaseId, const Inspector::InspectorObject& in_sqlError, const String& in_screenColor, const Inspector::InspectorArray& in_alternateColors, const String& in_printColor) = 0;
 };
 
 } // namespace Inspector
@@ -161,8 +161,8 @@
         Yellow = 5,
         Black = 6,
     }; // enum class PrintColor
-    virtual void executeAllOptionalParameters(ErrorString&, const RefPtr<Inspector::InspectorArray>&& in_columnNames, const String* in_notes, const double* in_timestamp, const RefPtr<Inspector::InspectorObject>&& in_values, const Inspector::InspectorValue* in_payload, const int* in_databaseId, const RefPtr<Inspector::InspectorObject>&& in_sqlError, const String* in_screenColor, const RefPtr<Inspector::InspectorArray>&& in_alternateColors, const String* in_printColor, RefPtr<Inspector::Protocol::Array<String>>& opt_out_columnNames, Inspector::Protocol::OptOutput<String>* opt_out_notes, Inspector::Protocol::OptOutput<double>* opt_out_timestamp, Inspector::Protocol::OptOutput<Inspector::InspectorObject>* opt_out_values, Inspector::Protocol::OptOutput<Inspector::InspectorValue>* opt_out_payload, Inspector::Protocol::OptOutput<int>* opt_out_databaseId, RefPtr<I
 nspector::Protocol::Database::Error>& opt_out_sqlError, Inspector::Protocol::Database::PrimaryColors* opt_out_screenColor, RefPtr<Inspector::Protocol::Database::ColorList>& opt_out_alternateColors, DatabaseBackendDispatcherHandler::PrintColor* opt_out_printColor) = 0;
-    virtual void executeNoOptionalParameters(ErrorString&, const RefPtr<Inspector::InspectorArray>&& in_columnNames, const String& in_notes, double in_timestamp, const RefPtr<Inspector::InspectorObject>&& in_values, Inspector::InspectorValue in_payload, int in_databaseId, const RefPtr<Inspector::InspectorObject>&& in_sqlError, const String& in_screenColor, const RefPtr<Inspector::InspectorArray>&& in_alternateColors, const String& in_printColor, RefPtr<Inspector::Protocol::Array<String>>& out_columnNames, String* out_notes, double* out_timestamp, Inspector::InspectorObject* out_values, Inspector::InspectorValue* out_payload, int* out_databaseId, RefPtr<Inspector::Protocol::Database::Error>& out_sqlError, Inspector::Protocol::Database::PrimaryColors* out_screenColor, RefPtr<Inspector::Protocol::Database::ColorList>& out_alternateColors, DatabaseBackendDispatcherHandler:
 :PrintColor* out_printColor) = 0;
+    virtual void executeAllOptionalParameters(ErrorString&, const Inspector::InspectorArray* opt_in_columnNames, const String* opt_in_notes, const double* opt_in_timestamp, const Inspector::InspectorObject* opt_in_values, const Inspector::InspectorValue* opt_in_payload, const int* opt_in_databaseId, const Inspector::InspectorObject* opt_in_sqlError, const String* opt_in_screenColor, const Inspector::InspectorArray* opt_in_alternateColors, const String* opt_in_printColor, RefPtr<Inspector::Protocol::Array<String>>& opt_out_columnNames, Inspector::Protocol::OptOutput<String>* opt_out_notes, Inspector::Protocol::OptOutput<double>* opt_out_timestamp, Inspector::Protocol::OptOutput<Inspector::InspectorObject>* opt_out_values, Inspector::Protocol::OptOutput<Inspector::InspectorValue>* opt_out_payload, Inspector::Protocol::OptOutput<int>* opt_out_databaseId, RefPtr<Inspector::Protocol::Database::Error>& opt_out_
 sqlError, Inspector::Protocol::Database::PrimaryColors* opt_out_screenColor, RefPtr<Inspector::Protocol::Database::ColorList>& opt_out_alternateColors, DatabaseBackendDispatcherHandler::PrintColor* opt_out_printColor) = 0;
+    virtual void executeNoOptionalParameters(ErrorString&, const Inspector::InspectorArray& in_columnNames, const String& in_notes, double in_timestamp, const Inspector::InspectorObject& in_values, Inspector::InspectorValue in_payload, int in_databaseId, const Inspector::InspectorObject& in_sqlError, const String& in_screenColor, const Inspector::InspectorArray& in_alternateColors, const String& in_printColor, RefPtr<Inspector::Protocol::Array<String>>& out_columnNames, String* out_notes, double* out_timestamp, Inspector::InspectorObject* out_values, Inspector::InspectorValue* out_payload, int* out_databaseId, RefPtr<Inspector::Protocol::Database::Error>& out_sqlError, Inspector::Protocol::Database::PrimaryColors* out_screenColor, RefPtr<Inspector::Protocol::Database::ColorList>& out_alternateColors, DatabaseBackendDispatcherHandler::PrintColor* out_printColor) = 0;
 protected:
     virtual ~DatabaseBackendDispatcherHandler();
 };
@@ -268,26 +268,26 @@
     auto protocolErrors = Inspector::Protocol::Array<String>::create();
     RefPtr<InspectorObject> paramsContainer;
     message.getObject(ASCIILiteral("params"), paramsContainer);
-    bool columnNames_valueFound = false;
-    RefPtr<Inspector::InspectorArray> in_columnNames = BackendDispatcher::getArray(paramsContainer.get(), ASCIILiteral("columnNames"), &columnNames_valueFound, protocolErrors.get());
-    bool notes_valueFound = false;
-    String in_notes = BackendDispatcher::getString(paramsContainer.get(), ASCIILiteral("notes"), &notes_valueFound, protocolErrors.get());
-    bool timestamp_valueFound = false;
-    Inspector::Protocol::OptOutput<double> in_timestamp = BackendDispatcher::getDouble(paramsContainer.get(), ASCIILiteral("timestamp"), &timestamp_valueFound, protocolErrors.get());
-    bool values_valueFound = false;
-    RefPtr<Inspector::InspectorObject> in_values = BackendDispatcher::getObject(paramsContainer.get(), ASCIILiteral("values"), &values_valueFound, protocolErrors.get());
-    bool payload_valueFound = false;
-    RefPtr<Inspector::InspectorValue> in_payload = BackendDispatcher::getValue(paramsContainer.get(), ASCIILiteral("payload"), &payload_valueFound, protocolErrors.get());
-    bool databaseId_valueFound = false;
-    int in_databaseId = BackendDispatcher::getInteger(paramsContainer.get(), ASCIILiteral("databaseId"), &databaseId_valueFound, protocolErrors.get());
-    bool sqlError_valueFound = false;
-    RefPtr<Inspector::InspectorObject> in_sqlError = BackendDispatcher::getObject(paramsContainer.get(), ASCIILiteral("sqlError"), &sqlError_valueFound, protocolErrors.get());
-    bool screenColor_valueFound = false;
-    String in_screenColor = BackendDispatcher::getString(paramsContainer.get(), ASCIILiteral("screenColor"), &screenColor_valueFound, protocolErrors.get());
-    bool alternateColors_valueFound = false;
-    RefPtr<Inspector::InspectorArray> in_alternateColors = BackendDispatcher::getArray(paramsContainer.get(), ASCIILiteral("alternateColors"), &alternateColors_valueFound, protocolErrors.get());
-    bool printColor_valueFound = false;
-    String in_printColor = BackendDispatcher::getString(paramsContainer.get(), ASCIILiteral("printColor"), &printColor_valueFound, protocolErrors.get());
+    bool opt_in_columnNames_valueFound = false;
+    RefPtr<Inspector::InspectorArray> opt_in_columnNames = BackendDispatcher::getArray(paramsContainer.get(), ASCIILiteral("columnNames"), &opt_in_columnNames_valueFound, protocolErrors.get());
+    bool opt_in_notes_valueFound = false;
+    String opt_in_notes = BackendDispatcher::getString(paramsContainer.get(), ASCIILiteral("notes"), &opt_in_notes_valueFound, protocolErrors.get());
+    bool opt_in_timestamp_valueFound = false;
+    Inspector::Protocol::OptOutput<double> opt_in_timestamp = BackendDispatcher::getDouble(paramsContainer.get(), ASCIILiteral("timestamp"), &opt_in_timestamp_valueFound, protocolErrors.get());
+    bool opt_in_values_valueFound = false;
+    RefPtr<Inspector::InspectorObject> opt_in_values = BackendDispatcher::getObject(paramsContainer.get(), ASCIILiteral("values"), &opt_in_values_valueFound, protocolErrors.get());
+    bool opt_in_payload_valueFound = false;
+    RefPtr<Inspector::InspectorValue> opt_in_payload = BackendDispatcher::getValue(paramsContainer.get(), ASCIILiteral("payload"), &opt_in_payload_valueFound, protocolErrors.get());
+    bool opt_in_databaseId_valueFound = false;
+    int opt_in_databaseId = BackendDispatcher::getInteger(paramsContainer.get(), ASCIILiteral("databaseId"), &opt_in_databaseId_valueFound, protocolErrors.get());
+    bool opt_in_sqlError_valueFound = false;
+    RefPtr<Inspector::InspectorObject> opt_in_sqlError = BackendDispatcher::getObject(paramsContainer.get(), ASCIILiteral("sqlError"), &opt_in_sqlError_valueFound, protocolErrors.get());
+    bool opt_in_screenColor_valueFound = false;
+    String opt_in_screenColor = BackendDispatcher::getString(paramsContainer.get(), ASCIILiteral("screenColor"), &opt_in_screenColor_valueFound, protocolErrors.get());
+    bool opt_in_alternateColors_valueFound = false;
+    RefPtr<Inspector::InspectorArray> opt_in_alternateColors = BackendDispatcher::getArray(paramsContainer.get(), ASCIILiteral("alternateColors"), &opt_in_alternateColors_valueFound, protocolErrors.get());
+    bool opt_in_printColor_valueFound = false;
+    String opt_in_printColor = BackendDispatcher::getString(paramsContainer.get(), ASCIILiteral("printColor"), &opt_in_printColor_valueFound, protocolErrors.get());
     if (protocolErrors->length()) {
         String errorMessage = String::format("Some arguments of method '%s' can't be processed", "Database.executeAllOptionalParameters");
         m_backendDispatcher->reportProtocolError(&callId, BackendDispatcher::InvalidParams, errorMessage, WTF::move(protocolErrors));
@@ -296,7 +296,7 @@
 
 #if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
     if (m_alternateDispatcher) {
-        m_alternateDispatcher->executeAllOptionalParameters(callId, columnNames_valueFound ? in_columnNames.copyRef() : nullptr, notes_valueFound ? &in_notes : nullptr, timestamp_valueFound ? &in_timestamp : nullptr, values_valueFound ? in_values.copyRef() : nullptr, payload_valueFound ? in_payload.copyRef() : nullptr, databaseId_valueFound ? &in_databaseId : nullptr, sqlError_valueFound ? in_sqlError.copyRef() : nullptr, screenColor_valueFound ? &in_screenColor : nullptr, alternateColors_valueFound ? in_alternateColors.copyRef() : nullptr, printColor_valueFound ? &in_printColor : nullptr);
+        m_alternateDispatcher->executeAllOptionalParameters(callId, opt_in_columnNames_valueFound ? opt_in_columnNames.get() : nullptr, opt_in_notes_valueFound ? &opt_in_notes : nullptr, opt_in_timestamp_valueFound ? &opt_in_timestamp : nullptr, opt_in_values_valueFound ? opt_in_values.get() : nullptr, opt_in_payload_valueFound ? opt_in_payload.get() : nullptr, opt_in_databaseId_valueFound ? &opt_in_databaseId : nullptr, opt_in_sqlError_valueFound ? opt_in_sqlError.get() : nullptr, opt_in_screenColor_valueFound ? &opt_in_screenColor : nullptr, opt_in_alternateColors_valueFound ? opt_in_alternateColors.get() : nullptr, opt_in_printColor_valueFound ? &opt_in_printColor : nullptr);
         return;
     }
 #endif
@@ -313,7 +313,7 @@
     Inspector::Protocol::Database::PrimaryColors out_screenColor;
     RefPtr<Inspector::Protocol::Database::ColorList> out_alternateColors;
     DatabaseBackendDispatcherHandler::PrintColor out_printColor;
-    m_agent->executeAllOptionalParameters(error, columnNames_valueFound ? in_columnNames.copyRef() : nullptr, notes_valueFound ? &in_notes : nullptr, timestamp_valueFound ? &in_timestamp : nullptr, values_valueFound ? in_values.copyRef() : nullptr, payload_valueFound ? in_payload.copyRef() : nullptr, databaseId_valueFound ? &in_databaseId : nullptr, sqlError_valueFound ? in_sqlError.copyRef() : nullptr, screenColor_valueFound ? &in_screenColor : nullptr, alternateColors_valueFound ? in_alternateColors.copyRef() : nullptr, printColor_valueFound ? &in_printColor : nullptr, out_columnNames, &out_notes, &out_timestamp, out_values, &out_payload, &out_databaseId, out_sqlError, &out_screenColor, out_alternateColors, &out_printColor);
+    m_agent->executeAllOptionalParameters(error, opt_in_columnNames_valueFound ? opt_in_columnNames.get() : nullptr, opt_in_notes_valueFound ? &opt_in_notes : nullptr, opt_in_timestamp_valueFound ? &opt_in_timestamp : nullptr, opt_in_values_valueFound ? opt_in_values.get() : nullptr, opt_in_payload_valueFound ? opt_in_payload.get() : nullptr, opt_in_databaseId_valueFound ? &opt_in_databaseId : nullptr, opt_in_sqlError_valueFound ? opt_in_sqlError.get() : nullptr, opt_in_screenColor_valueFound ? &opt_in_screenColor : nullptr, opt_in_alternateColors_valueFound ? opt_in_alternateColors.get() : nullptr, opt_in_printColor_valueFound ? &opt_in_printColor : nullptr, out_columnNames, &out_notes, &out_timestamp, out_values, &out_payload, &out_databaseId, out_sqlError, &out_screenColor, out_alternateColors, &out_printColor);
 
     if (!error.length()) {
         if (out_columnNames)
@@ -363,7 +363,7 @@
 
 #if ENABLE(INSPECTOR_ALTERNATE_DISPATCHERS)
     if (m_alternateDispatcher) {
-        m_alternateDispatcher->executeNoOptionalParameters(callId, in_columnNames.copyRef(), in_notes, in_timestamp, in_values.copyRef(), in_payload.copyRef(), in_databaseId, in_sqlError.copyRef(), in_screenColor, in_alternateColors.copyRef(), in_printColor);
+        m_alternateDispatcher->executeNoOptionalParameters(callId, *in_columnNames, in_notes, in_timestamp, *in_values, *in_payload, in_databaseId, *in_sqlError, in_screenColor, *in_alternateColors, in_printColor);
         return;
     }
 #endif
@@ -380,7 +380,7 @@
     Inspector::Protocol::Database::PrimaryColors out_screenColor;
     RefPtr<Inspector::Protocol::Database::ColorList> out_alternateColors;
     DatabaseBackendDispatcherHandler::PrintColor out_printColor;
-    m_agent->executeNoOptionalParameters(error, in_columnNames.copyRef(), in_notes, in_timestamp, in_values.copyRef(), in_payload.copyRef(), in_databaseId, in_sqlError.copyRef(), in_screenColor, in_alternateColors.copyRef(), in_printColor, out_columnNames, &out_notes, &out_timestamp, out_values, &out_payload, &out_databaseId, out_sqlError, &out_screenColor, out_alternateColors, &out_printColor);
+    m_agent->executeNoOptionalParameters(error, *in_columnNames, in_notes, in_timestamp, *in_values, *in_payload, in_databaseId, *in_sqlError, in_screenColor, *in_alternateColors, in_printColor, out_columnNames, &out_notes, &out_timestamp, out_values, &out_payload, &out_databaseId, out_sqlError, &out_screenColor, out_alternateColors, &out_printColor);
 
     if (!error.length()) {
         result->setArray(ASCIILiteral("columnNames"), out_columnNames);
@@ -744,8 +744,8 @@
 class ObjCInspectorDatabaseBackendDispatcher final : public AlternateDatabaseBackendDispatcher {
 public:
     ObjCInspectorDatabaseBackendDispatcher(id<RWIProtocolDatabaseDomainHandler> handler) { m_delegate = handler; }
-    virtual void executeAllOptionalParameters(long callId, const RefPtr<Inspector::InspectorArray>&& in_columnNames, const String* in_notes, const double* in_timestamp, const RefPtr<Inspector::InspectorObject>&& in_values, const Inspector::InspectorValue* in_payload, const int* in_databaseId, const RefPtr<Inspector::InspectorObject>&& in_sqlError, const String* in_screenColor, const RefPtr<Inspector::InspectorArray>&& in_alternateColors, const String* in_printColor) override;
-    virtual void executeNoOptionalParameters(long callId, const RefPtr<Inspector::InspectorArray>&& in_columnNames, const String& in_notes, double in_timestamp, const RefPtr<Inspector::InspectorObject>&& in_values, Inspector::InspectorValue in_payload, int in_databaseId, const RefPtr<Inspector::InspectorObject>&& in_sqlError, const String& in_screenColor, const RefPtr<Inspector::InspectorArray>&& in_alternateColors, const String& in_printColor) override;
+    virtual void executeAllOptionalParameters(long callId, const Inspector::InspectorArray* in_columnNames, const String* in_notes, const double* in_timestamp, const Inspector::InspectorObject* in_values, const Inspector::InspectorValue* in_payload, const int* in_databaseId, const Inspector::InspectorObject* in_sqlError, const String* in_screenColor, const Inspector::InspectorArray* in_alternateColors, const String* in_printColor) override;
+    virtual void executeNoOptionalParameters(long callId, const Inspector::InspectorArray& in_columnNames, const String& in_notes, double in_timestamp, const Inspector::InspectorObject& in_values, Inspector::InspectorValue in_payload, int in_databaseId, const Inspector::InspectorObject& in_sqlError, const String& in_screenColor, const Inspector::InspectorArray& in_alternateColors, const String& in_printColor) override;
 private:
     RetainPtr<id<RWIProtocolDatabaseDomainHandler>> m_delegate;
 };
@@ -924,7 +924,7 @@
 
 namespace Inspector {
 
-void ObjCInspectorDatabaseBackendDispatcher::executeAllOptionalParameters(long callId, const RefPtr<Inspector::InspectorArray>&& in_columnNames, const String* in_notes, const double* in_timestamp, const RefPtr<Inspector::InspectorObject>&& in_values, const Inspector::InspectorValue* in_payload, const int* in_databaseId, const RefPtr<Inspector::InspectorObject>&& in_sqlError, const String* in_screenColor, const RefPtr<Inspector::InspectorArray>&& in_alternateColors, const String* in_printColor)
+void ObjCInspectorDatabaseBackendDispatcher::executeAllOptionalParameters(long callId, const Inspector::InspectorArray* in_columnNames, const String* in_notes, const double* in_timestamp, const Inspector::InspectorObject* in_values, const Inspector::InspectorValue* in_payload, const int* in_databaseId, const Inspector::InspectorObject* in_sqlError, const String* in_screenColor, const Inspector::InspectorArray* in_alternateColors, const String* in_printColor)
 {
     id errorCallback = ^(NSString *error) {
         backendDispatcher()->sendResponse(callId, InspectorObject::create(), error);
@@ -963,7 +963,7 @@
 
     NSArray/*<NSString>*/ *o_in_columnNames;
     if (in_columnNames)
-        o_in_columnNames = objcStringArray(in_columnNames.copyRef());
+        o_in_columnNames = objcStringArray(in_columnNames);
     NSString *o_in_notes;
     if (in_notes)
         o_in_notes = *in_notes;
@@ -972,22 +972,22 @@
         o_in_timestamp = *in_timestamp;
     RWIProtocolJSONObject *o_in_values;
     if (in_values)
-        o_in_values = [[[RWIProtocolJSONObject alloc] initWithInspectorObject:*in_values] autorelease];
+        o_in_values = [[[RWIProtocolJSONObject alloc] initWithInspectorObject:in_values] autorelease];
     RWIProtocolJSONObject *o_in_payload;
     if (in_payload)
-        o_in_payload = [[[RWIProtocolJSONObject alloc] initWithInspectorObject:*in_payload] autorelease];
+        o_in_payload = [[[RWIProtocolJSONObject alloc] initWithInspectorObject:in_payload] autorelease];
     int o_in_databaseId;
     if (in_databaseId)
         o_in_databaseId = *in_databaseId;
     RWIProtocolDatabaseError *o_in_sqlError;
     if (in_sqlError)
-        o_in_sqlError = [[[RWIProtocolDatabaseError alloc] initWithInspectorObject:in_sqlError.copyRef()] autorelease];
+        o_in_sqlError = [[[RWIProtocolDatabaseError alloc] initWithInspectorObject:in_sqlError] autorelease];
     RWIProtocolDatabasePrimaryColors o_in_screenColor;
     if (in_screenColor)
         o_in_screenColor = fromProtocolString<RWIProtocolDatabasePrimaryColors>(*in_screenColor);
     NSArray/*<NSString>*/ *o_in_alternateColors;
     if (in_alternateColors)
-        o_in_alternateColors = objcStringArray(in_alternateColors.copyRef());
+        o_in_alternateColors = objcStringArray(in_alternateColors);
     RWIProtocolDatabaseExecuteAllOptionalParametersPrintColor o_in_printColor;
     if (in_printColor)
         o_in_printColor = fromProtocolString<RWIProtocolDatabaseExecuteAllOptionalParametersPrintColor>(*in_printColor);
@@ -995,7 +995,7 @@
     [m_delegate executeAllOptionalParametersWithErrorCallback:errorCallback successCallback:successCallback columnNames:(in_columnNames ? &o_in_columnNames : nil) notes:(in_notes ? &o_in_notes : nil) timestamp:(in_timestamp ? &o_in_timestamp : nil) values:(in_values ? &o_in_values : nil) payload:(in_payload ? &o_in_payload : nil) databaseId:(in_databaseId ? &o_in_databaseId : nil) sqlError:(in_sqlError ? &o_in_sqlError : nil) screenColor:(in_screenColor ? &o_in_screenColor : nil) alternateColors:(in_alternateColors ? &o_in_alternateColors : nil) printColor:(in_printColor ? &o_in_printColor : nil)];
 }
 
-void ObjCInspectorDatabaseBackendDispatcher::executeNoOptionalParameters(long callId, const RefPtr<Inspector::InspectorArray>&& in_columnNames, const String& in_notes, double in_timestamp, const RefPtr<Inspector::InspectorObject>&& in_values, Inspector::InspectorValue in_payload, int in_databaseId, const RefPtr<Inspector::InspectorObject>&& in_sqlError, const String& in_screenColor, const RefPtr<Inspector::InspectorArray>&& in_alternateColors, const String& in_printColor)
+void ObjCInspectorDatabaseBackendDispatcher::executeNoOptionalParameters(long callId, const Inspector::InspectorArray& in_columnNames, const String& in_notes, double in_timestamp, const Inspector::InspectorObject& in_values, Inspector::InspectorValue in_payload, int in_databaseId, const Inspector::InspectorObject& in_sqlError, const String& in_screenColor, const Inspector::InspectorArray& in_alternateColors, const String& in_printColor)
 {
     id errorCallback = ^(NSString *error) {
         backendDispatcher()->sendResponse(callId, InspectorObject::create(), error);
@@ -1022,15 +1022,15 @@
         backendDispatcher()->sendResponse(callId, WTF::move(resultObject), String());
     };
 
-    NSArray/*<NSString>*/ *o_in_columnNames = objcStringArray(in_columnNames.copyRef());
+    NSArray/*<NSString>*/ *o_in_columnNames = objcStringArray(&in_columnNames);
     NSString *o_in_notes = in_notes;
     double o_in_timestamp = in_timestamp;
-    RWIProtocolJSONObject *o_in_values = [[[RWIProtocolJSONObject alloc] initWithInspectorObject:in_values] autorelease];
-    RWIProtocolJSONObject *o_in_payload = [[[RWIProtocolJSONObject alloc] initWithInspectorObject:in_payload] autorelease];
+    RWIProtocolJSONObject *o_in_values = [[[RWIProtocolJSONObject alloc] initWithInspectorObject:&in_values] autorelease];
+    RWIProtocolJSONObject *o_in_payload = [[[RWIProtocolJSONObject alloc] initWithInspectorObject:&in_payload] autorelease];
     int o_in_databaseId = in_databaseId;
-    RWIProtocolDatabaseError *o_in_sqlError = [[[RWIProtocolDatabaseError alloc] initWithInspectorObject:in_sqlError.copyRef()] autorelease];
+    RWIProtocolDatabaseError *o_in_sqlError = [[[RWIProtocolDatabaseError alloc] initWithInspectorObject:&in_sqlError] autorelease];
     RWIProtocolDatabasePrimaryColors o_in_screenColor = fromProtocolString<RWIProtocolDatabasePrimaryColors>(in_screenColor);
-    NSArray/*<NSString>*/ *o_in_alternateColors = objcStringArray(in_alternateColors.copyRef());
+    NSArray/*<NSString>*/ *o_in_alternateColors = objcStringArray(&in_alternateColors);
     RWIProtocolDatabaseExecuteNoOptionalParametersPrintColor o_in_printColor = fromProtocolString<RWIProtocolDatabaseExecuteNoOptionalParametersPrintColor>(in_printColor);
 
     [m_delegate executeNoOptionalParametersWithErrorCallback:errorCallback successCallback:successCallback columnNames:o_in_columnNames notes:o_in_notes timestamp:o_in_timestamp values:o_in_values payload:o_in_payload databaseId:o_in_databaseId sqlError:o_in_sqlError screenColor:o_in_screenColor alternateColors:o_in_alternateColors printColor:o_in_printColor];

Modified: trunk/Source/WebCore/ChangeLog (185721 => 185722)


--- trunk/Source/WebCore/ChangeLog	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/ChangeLog	2015-06-18 22:07:15 UTC (rev 185722)
@@ -1,3 +1,62 @@
+2015-06-18  Brian J. Burg  <[email protected]>
+
+        Web Inspector: improve generated types for objects passed to backend commands
+        https://bugs.webkit.org/show_bug.cgi?id=146091
+
+        Reviewed by Joseph Pecoraro.
+
+        Update type signatures for backend command implementations. In a few cases, clean
+        up relevant helper function signatures and copy data out of parameter objects where
+        the code previously held onto a reference.
+
+        No new tests, no behavior changed.
+
+        * inspector/InspectorCSSAgent.cpp:
+        (WebCore::computePseudoClassMask):
+        (WebCore::InspectorCSSAgent::setStyleText):
+        (WebCore::InspectorCSSAgent::setRuleSelector):
+        (WebCore::InspectorCSSAgent::forcePseudoState):
+        * inspector/InspectorCSSAgent.h:
+        * inspector/InspectorDOMAgent.cpp:
+        (WebCore::parseColor):
+        (WebCore::parseConfigColor):
+        (WebCore::parseQuad):
+        (WebCore::InspectorDOMAgent::performSearch):
+        (WebCore::InspectorDOMAgent::setSearchingForNode):
+        (WebCore::InspectorDOMAgent::highlightConfigFromInspectorObject):
+        (WebCore::InspectorDOMAgent::setInspectModeEnabled):
+        (WebCore::InspectorDOMAgent::highlightRect):
+        (WebCore::InspectorDOMAgent::highlightQuad):
+        (WebCore::InspectorDOMAgent::innerHighlightQuad):
+        (WebCore::InspectorDOMAgent::highlightNode):
+        (WebCore::InspectorDOMAgent::highlightFrame):
+        * inspector/InspectorDOMAgent.h:
+        * inspector/InspectorDOMStorageAgent.cpp:
+        (WebCore::InspectorDOMStorageAgent::getDOMStorageItems):
+        (WebCore::InspectorDOMStorageAgent::setDOMStorageItem):
+        (WebCore::InspectorDOMStorageAgent::removeDOMStorageItem):
+        (WebCore::InspectorDOMStorageAgent::findStorageArea):
+        * inspector/InspectorDOMStorageAgent.h:
+        * inspector/InspectorIndexedDBAgent.cpp:
+        (WebCore::InspectorIndexedDBAgent::requestData):
+        * inspector/InspectorIndexedDBAgent.h:
+        * inspector/InspectorReplayAgent.cpp:
+        (WebCore::InspectorReplayAgent::replayToPosition):
+        * inspector/InspectorReplayAgent.h:
+        * inspector/InspectorResourceAgent.cpp:
+        (WebCore::InspectorResourceAgent::willSendRequest):
+        (WebCore::InspectorResourceAgent::setExtraHTTPHeaders):
+        Clean up extraHTTPHeaders to copy header key/values out of the InspectorObject, rather
+        than retaining the protocol object indefinitely. This matches the ownership scheme used
+        everywhere else.
+
+        * inspector/InspectorResourceAgent.h:
+        * inspector/InspectorStyleSheet.h:
+        (WebCore::InspectorCSSId::InspectorCSSId):
+        * inspector/InspectorWorkerAgent.cpp:
+        (WebCore::InspectorWorkerAgent::sendMessageToWorker):
+        * inspector/InspectorWorkerAgent.h:
+
 2015-06-18  Anders Carlsson  <[email protected]>
 
         Remove shouldInterruptJavaScript

Modified: trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -72,18 +72,18 @@
     PseudoClassVisited = 1 << 3
 };
 
-static unsigned computePseudoClassMask(InspectorArray* pseudoClassArray)
+static unsigned computePseudoClassMask(const InspectorArray& pseudoClassArray)
 {
     DEPRECATED_DEFINE_STATIC_LOCAL(String, active, (ASCIILiteral("active")));
     DEPRECATED_DEFINE_STATIC_LOCAL(String, hover, (ASCIILiteral("hover")));
     DEPRECATED_DEFINE_STATIC_LOCAL(String, focus, (ASCIILiteral("focus")));
     DEPRECATED_DEFINE_STATIC_LOCAL(String, visited, (ASCIILiteral("visited")));
-    if (!pseudoClassArray || !pseudoClassArray->length())
+    if (!pseudoClassArray.length())
         return PseudoClassNone;
 
     unsigned result = PseudoClassNone;
-    for (size_t i = 0; i < pseudoClassArray->length(); ++i) {
-        RefPtr<InspectorValue> pseudoClassValue = pseudoClassArray->get(i);
+    for (size_t i = 0; i < pseudoClassArray.length(); ++i) {
+        RefPtr<InspectorValue> pseudoClassValue = pseudoClassArray.get(i);
         String pseudoClass;
         bool success = pseudoClassValue->asString(pseudoClass);
         if (!success)
@@ -624,9 +624,9 @@
     errorString = InspectorDOMAgent::toErrorString(ec);
 }
 
-void InspectorCSSAgent::setStyleText(ErrorString& errorString, const RefPtr<InspectorObject>&& fullStyleId, const String& text, RefPtr<Inspector::Protocol::CSS::CSSStyle>& result)
+void InspectorCSSAgent::setStyleText(ErrorString& errorString, const InspectorObject& fullStyleId, const String& text, RefPtr<Inspector::Protocol::CSS::CSSStyle>& result)
 {
-    InspectorCSSId compoundId(fullStyleId.copyRef());
+    InspectorCSSId compoundId(fullStyleId);
     ASSERT(!compoundId.isEmpty());
 
     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
@@ -640,9 +640,9 @@
     errorString = InspectorDOMAgent::toErrorString(ec);
 }
 
-void InspectorCSSAgent::setRuleSelector(ErrorString& errorString, const RefPtr<InspectorObject>&& fullRuleId, const String& selector, RefPtr<Inspector::Protocol::CSS::CSSRule>& result)
+void InspectorCSSAgent::setRuleSelector(ErrorString& errorString, const InspectorObject& fullRuleId, const String& selector, RefPtr<Inspector::Protocol::CSS::CSSRule>& result)
 {
-    InspectorCSSId compoundId(fullRuleId.copyRef());
+    InspectorCSSId compoundId(fullRuleId);
     ASSERT(!compoundId.isEmpty());
 
     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
@@ -708,13 +708,13 @@
     cssProperties = WTF::move(properties);
 }
 
-void InspectorCSSAgent::forcePseudoState(ErrorString& errorString, int nodeId, const RefPtr<InspectorArray>&& forcedPseudoClasses)
+void InspectorCSSAgent::forcePseudoState(ErrorString& errorString, int nodeId, const InspectorArray& forcedPseudoClasses)
 {
     Element* element = m_domAgent->assertElement(errorString, nodeId);
     if (!element)
         return;
 
-    unsigned forcedPseudoState = computePseudoClassMask(forcedPseudoClasses.get());
+    unsigned forcedPseudoState = computePseudoClassMask(forcedPseudoClasses);
     NodeIdToForcedPseudoState::iterator it = m_nodeIdToForcedPseudoState.find(nodeId);
     unsigned currentForcedPseudoState = it == m_nodeIdToForcedPseudoState.end() ? 0 : it->value;
     bool needStyleRecalc = forcedPseudoState != currentForcedPseudoState;

Modified: trunk/Source/WebCore/inspector/InspectorCSSAgent.h (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorCSSAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorCSSAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -115,11 +115,11 @@
     virtual void getStyleSheet(ErrorString&, const String& styleSheetId, RefPtr<Inspector::Protocol::CSS::CSSStyleSheetBody>& result) override;
     virtual void getStyleSheetText(ErrorString&, const String& styleSheetId, String* result) override;
     virtual void setStyleSheetText(ErrorString&, const String& styleSheetId, const String& text) override;
-    virtual void setStyleText(ErrorString&, const RefPtr<Inspector::InspectorObject>&& styleId, const String& text, RefPtr<Inspector::Protocol::CSS::CSSStyle>& result) override;
-    virtual void setRuleSelector(ErrorString&, const RefPtr<Inspector::InspectorObject>&& ruleId, const String& selector, RefPtr<Inspector::Protocol::CSS::CSSRule>& result) override;
+    virtual void setStyleText(ErrorString&, const Inspector::InspectorObject& styleId, const String& text, RefPtr<Inspector::Protocol::CSS::CSSStyle>& result) override;
+    virtual void setRuleSelector(ErrorString&, const Inspector::InspectorObject& ruleId, const String& selector, RefPtr<Inspector::Protocol::CSS::CSSRule>& result) override;
     virtual void addRule(ErrorString&, int contextNodeId, const String& selector, RefPtr<Inspector::Protocol::CSS::CSSRule>& result) override;
     virtual void getSupportedCSSProperties(ErrorString&, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::CSS::CSSPropertyInfo>>& result) override;
-    virtual void forcePseudoState(ErrorString&, int nodeId, const RefPtr<Inspector::InspectorArray>&& forcedPseudoClasses) override;
+    virtual void forcePseudoState(ErrorString&, int nodeId, const Inspector::InspectorArray& forcedPseudoClasses) override;
     virtual void getNamedFlowCollection(ErrorString&, int documentNodeId, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::CSS::NamedFlow>>& result) override;
 
 private:

Modified: trunk/Source/WebCore/inspector/InspectorDOMAgent.cpp (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorDOMAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorDOMAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -103,7 +103,7 @@
 static const size_t maxTextSize = 10000;
 static const UChar ellipsisUChar[] = { 0x2026, 0 };
 
-static Color parseColor(const RefPtr<InspectorObject>&& colorObject)
+static Color parseColor(const InspectorObject* colorObject)
 {
     if (!colorObject)
         return Color::transparent;
@@ -127,23 +127,22 @@
     return Color(r, g, b, static_cast<int>(a * 255));
 }
 
-static Color parseConfigColor(const String& fieldName, InspectorObject* configObject)
+static Color parseConfigColor(const String& fieldName, const InspectorObject* configObject)
 {
     RefPtr<InspectorObject> colorObject;
     configObject->getObject(fieldName, colorObject);
-    return parseColor(WTF::move(colorObject));
+
+    return parseColor(colorObject.get());
 }
 
-static bool parseQuad(const RefPtr<InspectorArray>& quadArray, FloatQuad* quad)
+static bool parseQuad(const InspectorArray& quadArray, FloatQuad* quad)
 {
-    if (!quadArray)
-        return false;
     const size_t coordinatesInQuad = 8;
     double coordinates[coordinatesInQuad];
-    if (quadArray->length() != coordinatesInQuad)
+    if (quadArray.length() != coordinatesInQuad)
         return false;
     for (size_t i = 0; i < coordinatesInQuad; ++i) {
-        if (!quadArray->get(i)->asDouble(*(coordinates + i)))
+        if (!quadArray.get(i)->asDouble(*(coordinates + i)))
             return false;
     }
     quad->setP1(FloatPoint(coordinates[0], coordinates[1]));
@@ -874,7 +873,7 @@
     axProperties = buildObjectForAccessibilityProperties(node);
 }
 
-void InspectorDOMAgent::performSearch(ErrorString& errorString, const String& whitespaceTrimmedQuery, const RefPtr<InspectorArray>&& nodeIds, String* searchId, int* resultCount)
+void InspectorDOMAgent::performSearch(ErrorString& errorString, const String& whitespaceTrimmedQuery, const InspectorArray* nodeIds, String* searchId, int* resultCount)
 {
     // FIXME: Search works with node granularity - number of matches within node is not calculated.
     InspectorNodeFinder finder(whitespaceTrimmedQuery);
@@ -1012,7 +1011,7 @@
         m_overlay->highlightNode(node, *m_inspectModeHighlightConfig);
 }
 
-void InspectorDOMAgent::setSearchingForNode(ErrorString& errorString, bool enabled, InspectorObject* highlightInspectorObject)
+void InspectorDOMAgent::setSearchingForNode(ErrorString& errorString, bool enabled, const InspectorObject* highlightInspectorObject)
 {
     if (m_searchingForNode == enabled)
         return;
@@ -1027,7 +1026,7 @@
     m_overlay->didSetSearchingForNode(m_searchingForNode);
 }
 
-std::unique_ptr<HighlightConfig> InspectorDOMAgent::highlightConfigFromInspectorObject(ErrorString& errorString, InspectorObject* highlightInspectorObject)
+std::unique_ptr<HighlightConfig> InspectorDOMAgent::highlightConfigFromInspectorObject(ErrorString& errorString, const InspectorObject* highlightInspectorObject)
 {
     if (!highlightInspectorObject) {
         errorString = ASCIILiteral("Internal error: highlight configuration parameter is missing");
@@ -1046,37 +1045,37 @@
     return highlightConfig;
 }
 
-void InspectorDOMAgent::setInspectModeEnabled(ErrorString& errorString, bool enabled, const RefPtr<InspectorObject>&& highlightConfig)
+void InspectorDOMAgent::setInspectModeEnabled(ErrorString& errorString, bool enabled, const InspectorObject* highlightConfig)
 {
-    setSearchingForNode(errorString, enabled, highlightConfig ? highlightConfig.get() : nullptr);
+    setSearchingForNode(errorString, enabled, highlightConfig ? highlightConfig : nullptr);
 }
 
-void InspectorDOMAgent::highlightRect(ErrorString&, int x, int y, int width, int height, const RefPtr<InspectorObject>&& color, const RefPtr<InspectorObject>&& outlineColor, const bool* usePageCoordinates)
+void InspectorDOMAgent::highlightRect(ErrorString&, int x, int y, int width, int height, const InspectorObject* color, const InspectorObject* outlineColor, const bool* usePageCoordinates)
 {
     auto quad = std::make_unique<FloatQuad>(FloatRect(x, y, width, height));
-    innerHighlightQuad(WTF::move(quad), color.copyRef(), outlineColor.copyRef(), usePageCoordinates);
+    innerHighlightQuad(WTF::move(quad), color, outlineColor, usePageCoordinates);
 }
 
-void InspectorDOMAgent::highlightQuad(ErrorString& errorString, const RefPtr<InspectorArray>&& quadArray, const RefPtr<InspectorObject>&& color, const RefPtr<InspectorObject>&& outlineColor, const bool* usePageCoordinates)
+void InspectorDOMAgent::highlightQuad(ErrorString& errorString, const InspectorArray& quadArray, const InspectorObject* color, const InspectorObject* outlineColor, const bool* usePageCoordinates)
 {
     auto quad = std::make_unique<FloatQuad>();
     if (!parseQuad(quadArray, quad.get())) {
         errorString = ASCIILiteral("Invalid Quad format");
         return;
     }
-    innerHighlightQuad(WTF::move(quad), color.copyRef(), outlineColor.copyRef(), usePageCoordinates);
+    innerHighlightQuad(WTF::move(quad), color, outlineColor, usePageCoordinates);
 }
 
-void InspectorDOMAgent::innerHighlightQuad(std::unique_ptr<FloatQuad> quad, const RefPtr<InspectorObject>&& color, const RefPtr<InspectorObject>&& outlineColor, const bool* usePageCoordinates)
+void InspectorDOMAgent::innerHighlightQuad(std::unique_ptr<FloatQuad> quad, const InspectorObject* color, const InspectorObject* outlineColor, const bool* usePageCoordinates)
 {
     auto highlightConfig = std::make_unique<HighlightConfig>();
-    highlightConfig->content = parseColor(color.copyRef());
-    highlightConfig->contentOutline = parseColor(outlineColor.copyRef());
+    highlightConfig->content = parseColor(color);
+    highlightConfig->contentOutline = parseColor(outlineColor);
     highlightConfig->usePageCoordinates = usePageCoordinates ? *usePageCoordinates : false;
     m_overlay->highlightQuad(WTF::move(quad), *highlightConfig);
 }
 
-void InspectorDOMAgent::highlightNode(ErrorString& errorString, const RefPtr<InspectorObject>&& highlightInspectorObject, const int* nodeId, const String* objectId)
+void InspectorDOMAgent::highlightNode(ErrorString& errorString, const InspectorObject& highlightInspectorObject, const int* nodeId, const String* objectId)
 {
     Node* node = 0;
     if (nodeId) {
@@ -1091,21 +1090,21 @@
     if (!node)
         return;
 
-    std::unique_ptr<HighlightConfig> highlightConfig = highlightConfigFromInspectorObject(errorString, highlightInspectorObject.get());
+    std::unique_ptr<HighlightConfig> highlightConfig = highlightConfigFromInspectorObject(errorString, &highlightInspectorObject);
     if (!highlightConfig)
         return;
 
     m_overlay->highlightNode(node, *highlightConfig);
 }
 
-void InspectorDOMAgent::highlightFrame(ErrorString&, const String& frameId, const RefPtr<InspectorObject>&& color, const RefPtr<InspectorObject>&& outlineColor)
+void InspectorDOMAgent::highlightFrame(ErrorString&, const String& frameId, const InspectorObject* color, const InspectorObject* outlineColor)
 {
     Frame* frame = m_pageAgent->frameForId(frameId);
     if (frame && frame->ownerElement()) {
         auto highlightConfig = std::make_unique<HighlightConfig>();
         highlightConfig->showInfo = true; // Always show tooltips for frames.
-        highlightConfig->content = parseColor(color.copyRef());
-        highlightConfig->contentOutline = parseColor(outlineColor.copyRef());
+        highlightConfig->content = parseColor(color);
+        highlightConfig->contentOutline = parseColor(outlineColor);
         m_overlay->highlightNode(frame->ownerElement(), *highlightConfig);
     }
 }

Modified: trunk/Source/WebCore/inspector/InspectorDOMAgent.h (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorDOMAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorDOMAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -130,21 +130,21 @@
     virtual void setNodeValue(ErrorString&, int nodeId, const String& value) override;
     virtual void getEventListenersForNode(ErrorString&, int nodeId, const WTF::String* objectGroup, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::DOM::EventListener>>& listenersArray) override;
     virtual void getAccessibilityPropertiesForNode(ErrorString&, int nodeId, RefPtr<Inspector::Protocol::DOM::AccessibilityProperties>& axProperties) override;
-    virtual void performSearch(ErrorString&, const String& whitespaceTrimmedQuery, const RefPtr<Inspector::InspectorArray>&& nodeIds, String* searchId, int* resultCount) override;
+    virtual void performSearch(ErrorString&, const String& whitespaceTrimmedQuery, const Inspector::InspectorArray* nodeIds, String* searchId, int* resultCount) override;
     virtual void getSearchResults(ErrorString&, const String& searchId, int fromIndex, int toIndex, RefPtr<Inspector::Protocol::Array<int>>&) override;
     virtual void discardSearchResults(ErrorString&, const String& searchId) override;
     virtual void resolveNode(ErrorString&, int nodeId, const String* objectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>& result) override;
     virtual void getAttributes(ErrorString&, int nodeId, RefPtr<Inspector::Protocol::Array<String>>& result) override;
-    virtual void setInspectModeEnabled(ErrorString&, bool enabled, const RefPtr<Inspector::InspectorObject>&& highlightConfig) override;
+    virtual void setInspectModeEnabled(ErrorString&, bool enabled, const Inspector::InspectorObject* highlightConfig) override;
     virtual void requestNode(ErrorString&, const String& objectId, int* nodeId) override;
     virtual void pushNodeByPathToFrontend(ErrorString&, const String& path, int* nodeId) override;
     virtual void pushNodeByBackendIdToFrontend(ErrorString&, BackendNodeId, int* nodeId) override;
     virtual void releaseBackendNodeIds(ErrorString&, const String& nodeGroup) override;
     virtual void hideHighlight(ErrorString&) override;
-    virtual void highlightRect(ErrorString&, int x, int y, int width, int height, const RefPtr<Inspector::InspectorObject>&& color, const RefPtr<Inspector::InspectorObject>&& outlineColor, const bool* usePageCoordinates) override;
-    virtual void highlightQuad(ErrorString&, const RefPtr<Inspector::InspectorArray>&& quad, const RefPtr<Inspector::InspectorObject>&& color, const RefPtr<Inspector::InspectorObject>&& outlineColor, const bool* usePageCoordinates) override;
-    virtual void highlightNode(ErrorString&, const RefPtr<Inspector::InspectorObject>&& highlightConfig, const int* nodeId, const String* objectId) override;
-    virtual void highlightFrame(ErrorString&, const String& frameId, const RefPtr<Inspector::InspectorObject>&& color, const RefPtr<Inspector::InspectorObject>&& outlineColor) override;
+    virtual void highlightRect(ErrorString&, int x, int y, int width, int height, const Inspector::InspectorObject* color, const Inspector::InspectorObject* outlineColor, const bool* usePageCoordinates) override;
+    virtual void highlightQuad(ErrorString&, const Inspector::InspectorArray& quad, const Inspector::InspectorObject* color, const Inspector::InspectorObject* outlineColor, const bool* usePageCoordinates) override;
+    virtual void highlightNode(ErrorString&, const Inspector::InspectorObject& highlightConfig, const int* nodeId, const String* objectId) override;
+    virtual void highlightFrame(ErrorString&, const String& frameId, const Inspector::InspectorObject* color, const Inspector::InspectorObject* outlineColor) override;
 
     virtual void moveTo(ErrorString&, int nodeId, int targetNodeId, const int* anchorNodeId, int* newNodeId) override;
     virtual void undo(ErrorString&) override;
@@ -212,8 +212,8 @@
     InspectorPageAgent* pageAgent() { return m_pageAgent; }
 
 private:
-    void setSearchingForNode(ErrorString&, bool enabled, Inspector::InspectorObject* highlightConfig);
-    std::unique_ptr<HighlightConfig> highlightConfigFromInspectorObject(ErrorString&, Inspector::InspectorObject* highlightInspectorObject);
+    void setSearchingForNode(ErrorString&, bool enabled, const Inspector::InspectorObject* highlightConfig);
+    std::unique_ptr<HighlightConfig> highlightConfigFromInspectorObject(ErrorString&, const Inspector::InspectorObject* highlightInspectorObject);
 
     // Node-related methods.
     typedef HashMap<RefPtr<Node>, int> NodeToIdMap;
@@ -241,7 +241,7 @@
 
     void discardBindings();
 
-    void innerHighlightQuad(std::unique_ptr<FloatQuad>, const RefPtr<Inspector::InspectorObject>&& color, const RefPtr<Inspector::InspectorObject>&& outlineColor, const bool* usePageCoordinates);
+    void innerHighlightQuad(std::unique_ptr<FloatQuad>, const Inspector::InspectorObject* color, const Inspector::InspectorObject* outlineColor, const bool* usePageCoordinates);
 
     InspectorPageAgent* m_pageAgent;
     Inspector::InjectedScriptManager* m_injectedScriptManager;

Modified: trunk/Source/WebCore/inspector/InspectorDOMStorageAgent.cpp (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorDOMStorageAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorDOMStorageAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -92,10 +92,10 @@
     m_enabled = false;
 }
 
-void InspectorDOMStorageAgent::getDOMStorageItems(ErrorString& errorString, const RefPtr<InspectorObject>&& storageId, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Array<String>>>& items)
+void InspectorDOMStorageAgent::getDOMStorageItems(ErrorString& errorString, const InspectorObject& storageId, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Array<String>>>& items)
 {
     Frame* frame;
-    RefPtr<StorageArea> storageArea = findStorageArea(errorString, storageId.copyRef(), frame);
+    RefPtr<StorageArea> storageArea = findStorageArea(errorString, storageId, frame);
     if (!storageArea) {
         errorString = ASCIILiteral("No StorageArea for given storageId");
         return;
@@ -116,10 +116,10 @@
     items = WTF::move(storageItems);
 }
 
-void InspectorDOMStorageAgent::setDOMStorageItem(ErrorString& errorString, const RefPtr<InspectorObject>&& storageId, const String& key, const String& value)
+void InspectorDOMStorageAgent::setDOMStorageItem(ErrorString& errorString, const InspectorObject& storageId, const String& key, const String& value)
 {
     Frame* frame;
-    RefPtr<StorageArea> storageArea = findStorageArea(errorString, storageId.copyRef(), frame);
+    RefPtr<StorageArea> storageArea = findStorageArea(errorString, storageId, frame);
     if (!storageArea) {
         errorString = ASCIILiteral("Storage not found");
         return;
@@ -131,10 +131,10 @@
         errorString = ExceptionCodeDescription(QUOTA_EXCEEDED_ERR).name;
 }
 
-void InspectorDOMStorageAgent::removeDOMStorageItem(ErrorString& errorString, const RefPtr<InspectorObject>&& storageId, const String& key)
+void InspectorDOMStorageAgent::removeDOMStorageItem(ErrorString& errorString, const InspectorObject& storageId, const String& key)
 {
     Frame* frame;
-    RefPtr<StorageArea> storageArea = findStorageArea(errorString, storageId.copyRef(), frame);
+    RefPtr<StorageArea> storageArea = findStorageArea(errorString, storageId, frame);
     if (!storageArea) {
         errorString = ASCIILiteral("Storage not found");
         return;
@@ -180,13 +180,13 @@
         m_frontendDispatcher->domStorageItemUpdated(id, key, oldValue, newValue);
 }
 
-RefPtr<StorageArea> InspectorDOMStorageAgent::findStorageArea(ErrorString& errorString, const RefPtr<InspectorObject>&& storageId, Frame*& targetFrame)
+RefPtr<StorageArea> InspectorDOMStorageAgent::findStorageArea(ErrorString& errorString, const InspectorObject& storageId, Frame*& targetFrame)
 {
     String securityOrigin;
     bool isLocalStorage = false;
-    bool success = storageId->getString(ASCIILiteral("securityOrigin"), securityOrigin);
+    bool success = storageId.getString(ASCIILiteral("securityOrigin"), securityOrigin);
     if (success)
-        success = storageId->getBoolean(ASCIILiteral("isLocalStorage"), isLocalStorage);
+        success = storageId.getBoolean(ASCIILiteral("isLocalStorage"), isLocalStorage);
     if (!success) {
         errorString = ASCIILiteral("Invalid storageId format");
         targetFrame = nullptr;

Modified: trunk/Source/WebCore/inspector/InspectorDOMStorageAgent.h (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorDOMStorageAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorDOMStorageAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -63,9 +63,9 @@
     // Called from the front-end.
     virtual void enable(ErrorString&) override;
     virtual void disable(ErrorString&) override;
-    virtual void getDOMStorageItems(ErrorString&, const RefPtr<Inspector::InspectorObject>&& storageId, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Array<String>>>& items) override;
-    virtual void setDOMStorageItem(ErrorString&, const RefPtr<Inspector::InspectorObject>&& storageId, const String& key, const String& value) override;
-    virtual void removeDOMStorageItem(ErrorString&, const RefPtr<Inspector::InspectorObject>&& storageId, const String& key) override;
+    virtual void getDOMStorageItems(ErrorString&, const Inspector::InspectorObject& storageId, RefPtr<Inspector::Protocol::Array<Inspector::Protocol::Array<String>>>& items) override;
+    virtual void setDOMStorageItem(ErrorString&, const Inspector::InspectorObject& storageId, const String& key, const String& value) override;
+    virtual void removeDOMStorageItem(ErrorString&, const Inspector::InspectorObject& storageId, const String& key) override;
 
     // Called from the injected script.
     String storageId(Storage*);
@@ -75,7 +75,7 @@
     void didDispatchDOMStorageEvent(const String& key, const String& oldValue, const String& newValue, StorageType, SecurityOrigin*, Page*);
 
 private:
-    RefPtr<StorageArea> findStorageArea(ErrorString&, const RefPtr<Inspector::InspectorObject>&&, Frame*&);
+    RefPtr<StorageArea> findStorageArea(ErrorString&, const Inspector::InspectorObject&, Frame*&);
 
     InspectorPageAgent* m_pageAgent;
     std::unique_ptr<Inspector::DOMStorageFrontendDispatcher> m_frontendDispatcher;

Modified: trunk/Source/WebCore/inspector/InspectorIndexedDBAgent.cpp (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorIndexedDBAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorIndexedDBAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -378,7 +378,7 @@
     return idbKey.release();
 }
 
-static RefPtr<IDBKeyRange> idbKeyRangeFromKeyRange(InspectorObject* keyRange)
+static RefPtr<IDBKeyRange> idbKeyRangeFromKeyRange(const InspectorObject* keyRange)
 {
     RefPtr<InspectorObject> lower;
     if (!keyRange->getObject("lower", lower))
@@ -655,7 +655,7 @@
     databaseLoader->start(idbFactory, document->securityOrigin(), databaseName);
 }
 
-void InspectorIndexedDBAgent::requestData(ErrorString& errorString, const String& securityOrigin, const String& databaseName, const String& objectStoreName, const String& indexName, int skipCount, int pageSize, const RefPtr<InspectorObject>&& keyRange, Ref<RequestDataCallback>&& requestCallback)
+void InspectorIndexedDBAgent::requestData(ErrorString& errorString, const String& securityOrigin, const String& databaseName, const String& objectStoreName, const String& indexName, int skipCount, int pageSize, const InspectorObject* keyRange, Ref<RequestDataCallback>&& requestCallback)
 {
     Frame* frame = m_pageAgent->findFrameWithSecurityOrigin(securityOrigin);
     Document* document = assertDocument(errorString, frame);
@@ -668,7 +668,7 @@
 
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(mainWorldExecState(frame));
 
-    RefPtr<IDBKeyRange> idbKeyRange = keyRange ? idbKeyRangeFromKeyRange(keyRange.get()) : nullptr;
+    RefPtr<IDBKeyRange> idbKeyRange = keyRange ? idbKeyRangeFromKeyRange(keyRange) : nullptr;
     if (keyRange && !idbKeyRange) {
         errorString = ASCIILiteral("Can not parse key range.");
         return;

Modified: trunk/Source/WebCore/inspector/InspectorIndexedDBAgent.h (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorIndexedDBAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorIndexedDBAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -61,7 +61,7 @@
     virtual void disable(ErrorString&) override;
     virtual void requestDatabaseNames(ErrorString&, const String& securityOrigin, Ref<RequestDatabaseNamesCallback>&&) override;
     virtual void requestDatabase(ErrorString&, const String& securityOrigin, const String& databaseName, Ref<RequestDatabaseCallback>&&) override;
-    virtual void requestData(ErrorString&, const String& securityOrigin, const String& databaseName, const String& objectStoreName, const String& indexName, int skipCount, int pageSize, const RefPtr<Inspector::InspectorObject>&& keyRange, Ref<RequestDataCallback>&&) override;
+    virtual void requestData(ErrorString&, const String& securityOrigin, const String& databaseName, const String& objectStoreName, const String& indexName, int skipCount, int pageSize, const Inspector::InspectorObject* keyRange, Ref<RequestDataCallback>&&) override;
     virtual void clearObjectStore(ErrorString&, const String& in_securityOrigin, const String& in_databaseName, const String& in_objectStoreName, Ref<ClearObjectStoreCallback>&&) override;
 
 private:

Modified: trunk/Source/WebCore/inspector/InspectorReplayAgent.cpp (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorReplayAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorReplayAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -329,15 +329,15 @@
     m_page.replayController().stopCapturing();
 }
 
-void InspectorReplayAgent::replayToPosition(ErrorString& errorString, const RefPtr<InspectorObject>&& positionObject, bool fastReplay)
+void InspectorReplayAgent::replayToPosition(ErrorString& errorString, const InspectorObject& positionObject, bool fastReplay)
 {
     ReplayPosition position;
-    if (!positionObject->getInteger(ASCIILiteral("segmentOffset"), position.segmentOffset)) {
+    if (!positionObject.getInteger(ASCIILiteral("segmentOffset"), position.segmentOffset)) {
         errorString = ASCIILiteral("Couldn't decode ReplayPosition segment offset provided to ReplayAgent.replayToPosition.");
         return;
     }
 
-    if (!positionObject->getInteger(ASCIILiteral("inputOffset"), position.inputOffset)) {
+    if (!positionObject.getInteger(ASCIILiteral("inputOffset"), position.inputOffset)) {
         errorString = ASCIILiteral("Couldn't decode ReplayPosition input offset provided to ReplayAgent.replayToPosition.");
         return;
     }

Modified: trunk/Source/WebCore/inspector/InspectorReplayAgent.h (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorReplayAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorReplayAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -96,7 +96,7 @@
     virtual void startCapturing(ErrorString&) override;
     virtual void stopCapturing(ErrorString&) override;
 
-    virtual void replayToPosition(ErrorString&, const RefPtr<Inspector::InspectorObject>&&, bool shouldFastForward) override;
+    virtual void replayToPosition(ErrorString&, const Inspector::InspectorObject& position, bool shouldFastForward) override;
     virtual void replayToCompletion(ErrorString&, bool shouldFastForward) override;
     virtual void pausePlayback(ErrorString&) override;
     virtual void cancelPlayback(ErrorString&) override;

Modified: trunk/Source/WebCore/inspector/InspectorResourceAgent.cpp (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorResourceAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorResourceAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -299,14 +299,8 @@
 
     m_resourcesData->setResourceType(requestId, type);
 
-    if (m_extraRequestHeaders) {
-        InspectorObject::const_iterator end = m_extraRequestHeaders->end();
-        for (InspectorObject::const_iterator it = m_extraRequestHeaders->begin(); it != end; ++it) {
-            String value;
-            if (it->value->asString(value))
-                request.setHTTPHeaderField(it->key, value);
-        }
-    }
+    for (auto& entry : m_extraRequestHeaders)
+        request.setHTTPHeaderField(entry.key, entry.value);
 
     request.setReportLoadTiming(true);
     request.setReportRawHeaders(true);
@@ -624,9 +618,13 @@
     m_extraRequestHeaders.clear();
 }
 
-void InspectorResourceAgent::setExtraHTTPHeaders(ErrorString&, const RefPtr<InspectorObject>&& headers)
+void InspectorResourceAgent::setExtraHTTPHeaders(ErrorString&, const InspectorObject& headers)
 {
-    m_extraRequestHeaders = headers.copyRef();
+    for (auto& entry : headers) {
+        String stringValue;
+        if (entry.value->asString(stringValue))
+            m_extraRequestHeaders.set(entry.key, stringValue);
+    }
 }
 
 void InspectorResourceAgent::getResponseBody(ErrorString& errorString, const String& requestId, String* content, bool* base64Encoded)

Modified: trunk/Source/WebCore/inspector/InspectorResourceAgent.h (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorResourceAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorResourceAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -117,7 +117,7 @@
     // Called from frontend.
     virtual void enable(ErrorString&) override;
     virtual void disable(ErrorString&) override;
-    virtual void setExtraHTTPHeaders(ErrorString&, const RefPtr<Inspector::InspectorObject>&&) override;
+    virtual void setExtraHTTPHeaders(ErrorString&, const Inspector::InspectorObject& headers) override;
     virtual void getResponseBody(ErrorString&, const String& requestId, String* content, bool* base64Encoded) override;
     virtual void canClearBrowserCache(ErrorString&, bool*) override;
     virtual void clearBrowserCache(ErrorString&) override;
@@ -139,7 +139,7 @@
     bool m_enabled;
     bool m_cacheDisabled;
     bool m_loadingXHRSynchronously;
-    RefPtr<Inspector::InspectorObject> m_extraRequestHeaders;
+    HashMap<String, String> m_extraRequestHeaders;
 
     HashSet<unsigned long> m_hiddenRequestIdentifiers;
 

Modified: trunk/Source/WebCore/inspector/InspectorStyleSheet.h (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorStyleSheet.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorStyleSheet.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -56,12 +56,12 @@
 public:
     InspectorCSSId() { }
 
-    explicit InspectorCSSId(const RefPtr<Inspector::InspectorObject>&& value)
+    explicit InspectorCSSId(const Inspector::InspectorObject& value)
     {
-        if (!value->getString(ASCIILiteral("styleSheetId"), m_styleSheetId))
+        if (!value.getString(ASCIILiteral("styleSheetId"), m_styleSheetId))
             return;
 
-        if (!value->getInteger(ASCIILiteral("ordinal"), m_ordinal))
+        if (!value.getInteger(ASCIILiteral("ordinal"), m_ordinal))
             m_styleSheetId = String();
     }
 

Modified: trunk/Source/WebCore/inspector/InspectorWorkerAgent.cpp (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorWorkerAgent.cpp	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorWorkerAgent.cpp	2015-06-18 22:07:15 UTC (rev 185722)
@@ -171,11 +171,11 @@
         error = ASCIILiteral("Worker is gone");
 }
 
-void InspectorWorkerAgent::sendMessageToWorker(ErrorString& error, int workerId, const RefPtr<InspectorObject>&& message)
+void InspectorWorkerAgent::sendMessageToWorker(ErrorString& error, int workerId, const InspectorObject& message)
 {
     WorkerFrontendChannel* channel = m_idToChannel.get(workerId);
     if (channel)
-        channel->proxy()->sendMessageToInspector(message->toJSONString());
+        channel->proxy()->sendMessageToInspector(message.toJSONString());
     else
         error = ASCIILiteral("Worker is gone");
 }

Modified: trunk/Source/WebCore/inspector/InspectorWorkerAgent.h (185721 => 185722)


--- trunk/Source/WebCore/inspector/InspectorWorkerAgent.h	2015-06-18 20:59:12 UTC (rev 185721)
+++ trunk/Source/WebCore/inspector/InspectorWorkerAgent.h	2015-06-18 22:07:15 UTC (rev 185722)
@@ -68,7 +68,7 @@
     virtual void canInspectWorkers(ErrorString&, bool*) override;
     virtual void connectToWorker(ErrorString&, int workerId) override;
     virtual void disconnectFromWorker(ErrorString&, int workerId) override;
-    virtual void sendMessageToWorker(ErrorString&, int workerId, const RefPtr<Inspector::InspectorObject>&& message) override;
+    virtual void sendMessageToWorker(ErrorString&, int workerId, const Inspector::InspectorObject& message) override;
     virtual void setAutoconnectToWorkers(ErrorString&, bool value) override;
 
 private:
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to