DevTools: introduce protocol::Value, baseline for hierarchical data in remote debugging protocol.

third_party/WebKit/Source/core/inspector/InspectorResourceAgent.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 40 matching lines @@
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InspectedFrames.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/NetworkResourcesData.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/MixedContentChecker.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/page/Page.h"
 #include "core/xmlhttprequest/XMLHttpRequest.h"
-#include "platform/JSONValues.h"
 #include "platform/blob/BlobData.h"
 #include "platform/inspector_protocol/Frontend.h"
+#include "platform/inspector_protocol/Values.h"
 #include "platform/network/HTTPHeaderMap.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceLoadPriority.h"
 #include "platform/network/ResourceLoadTiming.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/network/WebSocketHandshakeRequest.h"
 #include "platform/network/WebSocketHandshakeResponse.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/WebURLRequest.h"
@@ skipping 30 matching lines @@
         pos = url.find(part, pos);
         if (pos == kNotFound)
             return false;
         pos += part.length();
     }
     return true;
 }
 
 static PassOwnPtr<protocol::Network::Headers> buildObjectForHeaders(const HTTPHeaderMap& headers)
 {
-    RefPtr<JSONObject> headersObject = JSONObject::create();
+    RefPtr<protocol::DictionaryValue> headersObject = protocol::DictionaryValue::create();
     for (const auto& header : headers)
         headersObject->setString(header.key.string(), header.value);
     protocol::ErrorSupport errors;
     return protocol::Network::Headers::parse(headersObject, &errors);
 }
 
 class InspectorFileReaderLoaderClient final : public FileReaderLoaderClient {
     WTF_MAKE_NONCOPYABLE(InspectorFileReaderLoaderClient);
 public:
     InspectorFileReaderLoaderClient(PassRefPtr<BlobDataHandle> blob, PassOwnPtr<TextResourceDecoder> decoder, PassRefPtr<GetResponseBodyCallback> callback)
@@ skipping 168 matching lines @@
 
     double status;
     String statusText;
     if (response.resourceLoadInfo() && response.resourceLoadInfo()->httpStatusCode) {
         status = response.resourceLoadInfo()->httpStatusCode;
         statusText = response.resourceLoadInfo()->httpStatusText;
     } else {
         status = response.httpStatusCode();
         statusText = response.httpStatusText();
     }
-    RefPtr<JSONObject> headers;
+    RefPtr<protocol::DictionaryValue> headers;
     HTTPHeaderMap headersMap;
     if (response.resourceLoadInfo() && response.resourceLoadInfo()->responseHeaders.size())
         headersMap = response.resourceLoadInfo()->responseHeaders;
     else
         headersMap = response.httpHeaderFields();
 
     int64_t encodedDataLength = response.resourceLoadInfo() ? response.resourceLoadInfo()->encodedDataLength : -1;
 
     String securityState = protocol::Security::SecurityStateEnum::Unknown;
     switch (response.securityStyle()) {
@@ skipping 118 matching lines @@
     visitor->trace(m_inspectedFrames);
     visitor->trace(m_resourcesData);
     visitor->trace(m_replayXHRs);
     visitor->trace(m_replayXHRsToBeDeleted);
     visitor->trace(m_pendingXHRReplayData);
     InspectorBaseAgent::trace(visitor);
 }
 
 bool InspectorResourceAgent::shouldBlockRequest(const ResourceRequest& request)
 {
-    RefPtr<JSONObject> blockedURLs = m_state->getObject(ResourceAgentState::blockedURLs);
+    RefPtr<protocol::DictionaryValue> blockedURLs = m_state->getObject(ResourceAgentState::blockedURLs);
     if (!blockedURLs)
         return false;
     String url = request.url().string();
     for (const auto& entry : *blockedURLs) {
         if (matches(url, entry.key))
             return true;
     }
     return false;
 }
 
@@ skipping 42 matching lines @@
 
 void InspectorResourceAgent::willSendRequest(LocalFrame* frame, unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& redirectResponse, const FetchInitiatorInfo& initiatorInfo)
 {
     // Ignore the request initiated internally.
     if (initiatorInfo.name == FetchInitiatorTypeNames::internal)
         return;
 
     if (initiatorInfo.name == FetchInitiatorTypeNames::document && loader->substituteData().isValid())
         return;
 
-    RefPtr<JSONObject> headers = m_state->getObject(ResourceAgentState::extraRequestHeaders);
+    RefPtr<protocol::DictionaryValue> headers = m_state->getObject(ResourceAgentState::extraRequestHeaders);
     if (headers) {
         for (const auto& header : *headers) {
             String value;
             if (header.value->asString(&value))
                 request.setHTTPHeaderField(AtomicString(header.key), AtomicString(value));
         }
     }
 
     request.setReportRawHeaders(true);
 
@@ skipping 444 matching lines @@
     }
 
     if (getResponseBodyBlob(requestId, callback))
         return;
 
     callback->sendFailure("No data found for resource with given identifier");
 }
 
 void InspectorResourceAgent::addBlockedURL(ErrorString*, const String& url)
 {
-    RefPtr<JSONObject> blockedURLs = m_state->getObject(ResourceAgentState::blockedURLs);
+    RefPtr<protocol::DictionaryValue> blockedURLs = m_state->getObject(ResourceAgentState::blockedURLs);
     if (!blockedURLs) {
-        blockedURLs = JSONObject::create();
+        blockedURLs = protocol::DictionaryValue::create();
         m_state->setObject(ResourceAgentState::blockedURLs, blockedURLs);
     }
     blockedURLs->setBoolean(url, true);
 }
 
 void InspectorResourceAgent::removeBlockedURL(ErrorString*, const String& url)
 {
-    RefPtr<JSONObject> blockedURLs = m_state->getObject(ResourceAgentState::blockedURLs);
+    RefPtr<protocol::DictionaryValue> blockedURLs = m_state->getObject(ResourceAgentState::blockedURLs);
     if (blockedURLs)
         blockedURLs->remove(url);
 }
 
 void InspectorResourceAgent::replayXHR(ErrorString*, const String& requestId)
 {
     String actualRequestId = requestId;
 
     XHRReplayData* xhrReplayData = m_resourcesData->xhrReplayData(requestId);
     if (!xhrReplayData)
@@ skipping 111 matching lines @@
     , m_removeFinishedReplayXHRTimer(this, &InspectorResourceAgent::removeFinishedReplayXHRFired)
 {
 }
 
 bool InspectorResourceAgent::shouldForceCORSPreflight()
 {
     return m_state->booleanProperty(ResourceAgentState::cacheDisabled, false);
 }
 
 } // namespace blink