[DevTools] migrate NetworkAgent to new style

third_party/WebKit/Source/core/inspector/InspectorNetworkAgent.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 146 matching lines @@
     m_rawData->append(data, dataLength);
   }
 
   virtual void didFinishLoading() {
     String result;
     bool base64Encoded;
     if (InspectorPageAgent::sharedBufferContent(
             m_rawData, m_mimeType, m_textEncodingName, &result, &base64Encoded))
       m_callback->sendSuccess(result, base64Encoded);
     else
-      m_callback->sendFailure("Couldn't encode data");
+      m_callback->sendFailure(Response::Error("Couldn't encode data"));
     dispose();
   }
 
   virtual void didFail(FileError::ErrorCode) {
-    m_callback->sendFailure("Couldn't read BLOB");
+    m_callback->sendFailure(Response::Error("Couldn't read BLOB"));
     dispose();
   }
 
  private:
   void dispose() {
     m_rawData.clear();
     delete this;
   }
 
   RefPtr<BlobDataHandle> m_blob;
@@ skipping 59 matching lines @@
       return protocol::Network::BlockedReasonEnum::SubresourceFilter;
     case ResourceRequestBlockedReasonOther:
       return protocol::Network::BlockedReasonEnum::Other;
     case ResourceRequestBlockedReasonNone:
     default:
       NOTREACHED();
       return protocol::Network::BlockedReasonEnum::Other;
   }
 }
 
-WebConnectionType toWebConnectionType(ErrorString* errorString,
-                                      const String& connectionType) {
+WebConnectionType toWebConnectionType(const String& connectionType) {
   if (connectionType == protocol::Network::ConnectionTypeEnum::None)
     return WebConnectionTypeNone;
   if (connectionType == protocol::Network::ConnectionTypeEnum::Cellular2g)
     return WebConnectionTypeCellular2G;
   if (connectionType == protocol::Network::ConnectionTypeEnum::Cellular3g)
     return WebConnectionTypeCellular3G;
   if (connectionType == protocol::Network::ConnectionTypeEnum::Cellular4g)
     return WebConnectionTypeCellular4G;
   if (connectionType == protocol::Network::ConnectionTypeEnum::Bluetooth)
     return WebConnectionTypeBluetooth;
   if (connectionType == protocol::Network::ConnectionTypeEnum::Ethernet)
     return WebConnectionTypeEthernet;
   if (connectionType == protocol::Network::ConnectionTypeEnum::Wifi)
     return WebConnectionTypeWifi;
   if (connectionType == protocol::Network::ConnectionTypeEnum::Wimax)
     return WebConnectionTypeWimax;
   if (connectionType == protocol::Network::ConnectionTypeEnum::Other)
     return WebConnectionTypeOther;
-  *errorString = "Unknown connection type";
   return WebConnectionTypeUnknown;
 }
 
 }  // namespace
 
 void InspectorNetworkAgent::restore() {
   if (m_state->booleanProperty(NetworkAgentState::networkAgentEnabled, false)) {
     enable(m_state->integerProperty(NetworkAgentState::totalBufferSize,
                                     maximumTotalBufferSize),
            m_state->integerProperty(NetworkAgentState::resourceBufferSize,
@@ skipping 843 matching lines @@
                                  std::move(frameObject));
 }
 
 void InspectorNetworkAgent::didReceiveWebSocketFrameError(
     unsigned long identifier,
     const String& errorMessage) {
   frontend()->webSocketFrameError(IdentifiersFactory::requestId(identifier),
                                   monotonicallyIncreasingTime(), errorMessage);
 }
 
-void InspectorNetworkAgent::enable(ErrorString*,
-                                   const Maybe<int>& totalBufferSize,
-                                   const Maybe<int>& resourceBufferSize) {
+Response InspectorNetworkAgent::enable(Maybe<int> totalBufferSize,
+                                       Maybe<int> resourceBufferSize) {
   enable(totalBufferSize.fromMaybe(maximumTotalBufferSize),
          resourceBufferSize.fromMaybe(maximumResourceBufferSize));
+  return Response::OK();
 }
 
 void InspectorNetworkAgent::enable(int totalBufferSize,
                                    int resourceBufferSize) {
   if (!frontend())
     return;
   m_resourcesData->setResourcesDataSizeLimits(totalBufferSize,
                                               resourceBufferSize);
   m_state->setBoolean(NetworkAgentState::networkAgentEnabled, true);
   m_state->setInteger(NetworkAgentState::totalBufferSize, totalBufferSize);
   m_state->setInteger(NetworkAgentState::resourceBufferSize,
                       resourceBufferSize);
   m_instrumentingAgents->addInspectorNetworkAgent(this);
 }
 
-void InspectorNetworkAgent::disable(ErrorString*) {
+Response InspectorNetworkAgent::disable() {
   DCHECK(!m_pendingRequest);
   m_state->setBoolean(NetworkAgentState::networkAgentEnabled, false);
   m_state->setString(NetworkAgentState::userAgentOverride, "");
   m_instrumentingAgents->removeInspectorNetworkAgent(this);
   m_resourcesData->clear();
   m_knownRequestIdMap.clear();
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::setUserAgentOverride(ErrorString* errorString,
-                                                 const String& userAgent) {
+Response InspectorNetworkAgent::setUserAgentOverride(const String& userAgent) {
   if (userAgent.contains('\n') || userAgent.contains('\r') ||
       userAgent.contains('\0')) {
-    *errorString = "Invalid characters found in userAgent";
-    return;
+    return Response::Error("Invalid characters found in userAgent");
   }
   m_state->setString(NetworkAgentState::userAgentOverride, userAgent);
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::setExtraHTTPHeaders(
-    ErrorString*,
+Response InspectorNetworkAgent::setExtraHTTPHeaders(
     const std::unique_ptr<protocol::Network::Headers> headers) {
   m_state->setObject(NetworkAgentState::extraRequestHeaders,
                      headers->serialize());
+  return Response::OK();
 }
 
 bool InspectorNetworkAgent::canGetResponseBodyBlob(const String& requestId) {
   NetworkResourcesData::ResourceData const* resourceData =
       m_resourcesData->data(requestId);
   BlobDataHandle* blob =
       resourceData ? resourceData->downloadedFileBlob() : nullptr;
   if (!blob)
     return false;
   LocalFrame* frame =
@@ skipping 16 matching lines @@
   client->start(document);
 }
 
 void InspectorNetworkAgent::getResponseBody(
     const String& requestId,
     std::unique_ptr<GetResponseBodyCallback> passCallback) {
   std::unique_ptr<GetResponseBodyCallback> callback = std::move(passCallback);
   NetworkResourcesData::ResourceData const* resourceData =
       m_resourcesData->data(requestId);
   if (!resourceData) {
-    callback->sendFailure("No resource with given identifier found");
+    callback->sendFailure(
+        Response::Error("No resource with given identifier found"));
     return;
   }
 
   // XHR with ResponseTypeBlob should be returned as blob.
   if (resourceData->xhrReplayData() && canGetResponseBodyBlob(requestId)) {
     getResponseBodyBlob(requestId, std::move(callback));
     return;
   }
 
   if (resourceData->hasContent()) {
     callback->sendSuccess(resourceData->content(),
                           resourceData->base64Encoded());
     return;
   }
 
   if (resourceData->isContentEvicted()) {
-    callback->sendFailure("Request content was evicted from inspector cache");
+    callback->sendFailure(
+        Response::Error("Request content was evicted from inspector cache"));
     return;
   }
 
   if (resourceData->buffer() && !resourceData->textEncodingName().isNull()) {
     String result;
     bool base64Encoded;
     bool success = InspectorPageAgent::sharedBufferContent(
         resourceData->buffer(), resourceData->mimeType(),
         resourceData->textEncodingName(), &result, &base64Encoded);
     DCHECK(success);
     callback->sendSuccess(result, base64Encoded);
     return;
   }
 
   if (resourceData->cachedResource()) {
     String content;
     bool base64Encoded = false;
     if (InspectorPageAgent::cachedResourceContent(
             resourceData->cachedResource(), &content, &base64Encoded)) {
       callback->sendSuccess(content, base64Encoded);
       return;
     }
   }
 
   if (canGetResponseBodyBlob(requestId)) {
     getResponseBodyBlob(requestId, std::move(callback));
     return;
   }
 
-  callback->sendFailure("No data found for resource with given identifier");
+  callback->sendFailure(
+      Response::Error("No data found for resource with given identifier"));
 }
 
-void InspectorNetworkAgent::addBlockedURL(ErrorString*, const String& url) {
+Response InspectorNetworkAgent::addBlockedURL(const String& url) {
   protocol::DictionaryValue* blockedURLs =
       m_state->getObject(NetworkAgentState::blockedURLs);
   if (!blockedURLs) {
     std::unique_ptr<protocol::DictionaryValue> newList =
         protocol::DictionaryValue::create();
     blockedURLs = newList.get();
     m_state->setObject(NetworkAgentState::blockedURLs, std::move(newList));
   }
   blockedURLs->setBoolean(url, true);
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::removeBlockedURL(ErrorString*, const String& url) {
+Response InspectorNetworkAgent::removeBlockedURL(const String& url) {
   protocol::DictionaryValue* blockedURLs =
       m_state->getObject(NetworkAgentState::blockedURLs);
   if (blockedURLs)
     blockedURLs->remove(url);
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::replayXHR(ErrorString*, const String& requestId) {
+Response InspectorNetworkAgent::replayXHR(const String& requestId) {
   String actualRequestId = requestId;
 
   XHRReplayData* xhrReplayData = m_resourcesData->xhrReplayData(requestId);
   if (!xhrReplayData)
-    return;
+    return Response::Error("Given id does not correspond to XHR");
 
   ExecutionContext* executionContext = xhrReplayData->getExecutionContext();
   if (!executionContext) {
     m_resourcesData->setXHRReplayData(requestId, 0);
-    return;
+    return Response::Error("Document is already detached");
   }
 
   XMLHttpRequest* xhr = XMLHttpRequest::create(executionContext);
 
   executionContext->removeURLFromMemoryCache(xhrReplayData->url());
 
   xhr->open(xhrReplayData->method(), xhrReplayData->url(),
             xhrReplayData->async(), IGNORE_EXCEPTION);
   if (xhrReplayData->includeCredentials())
     xhr->setWithCredentials(true, IGNORE_EXCEPTION);
   for (const auto& header : xhrReplayData->headers())
     xhr->setRequestHeader(header.key, header.value, IGNORE_EXCEPTION);
   xhr->sendForInspectorXHRReplay(xhrReplayData->formData(), IGNORE_EXCEPTION);
 
   m_replayXHRs.add(xhr);
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::setMonitoringXHREnabled(ErrorString*,
-                                                    bool enabled) {
+Response InspectorNetworkAgent::setMonitoringXHREnabled(bool enabled) {
   m_state->setBoolean(NetworkAgentState::monitoringXHR, enabled);
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::canClearBrowserCache(ErrorString*, bool* result) {
+Response InspectorNetworkAgent::canClearBrowserCache(bool* result) {
   *result = true;
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::canClearBrowserCookies(ErrorString*, bool* result) {
+Response InspectorNetworkAgent::canClearBrowserCookies(bool* result) {
   *result = true;
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::emulateNetworkConditions(
-    ErrorString* errorString,
+Response InspectorNetworkAgent::emulateNetworkConditions(
     bool offline,
     double latency,
     double downloadThroughput,
     double uploadThroughput,
-    const Maybe<String>& connectionType) {
+    Maybe<String> connectionType) {
   WebConnectionType type = WebConnectionTypeUnknown;
   if (connectionType.isJust()) {
-    type = toWebConnectionType(errorString, connectionType.fromJust());
-    if (!errorString->isEmpty())
-      return;
+    type = toWebConnectionType(connectionType.fromJust());
+    if (type == WebConnectionTypeUnknown)
+      return Response::Error("Unknown connection type");
   }
   // TODO(dgozman): networkStateNotifier is per-process. It would be nice to
   // have per-frame override instead.
   if (offline || latency || downloadThroughput || uploadThroughput)
     networkStateNotifier().setOverride(!offline, type,
                                        downloadThroughput / (1024 * 1024 / 8));
   else
     networkStateNotifier().clearOverride();
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::setCacheDisabled(ErrorString*, bool cacheDisabled) {
+Response InspectorNetworkAgent::setCacheDisabled(bool cacheDisabled) {
   m_state->setBoolean(NetworkAgentState::cacheDisabled, cacheDisabled);
   if (cacheDisabled)
     memoryCache()->evictResources();
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::setBypassServiceWorker(ErrorString*, bool bypass) {
+Response InspectorNetworkAgent::setBypassServiceWorker(bool bypass) {
   m_state->setBoolean(NetworkAgentState::bypassServiceWorker, bypass);
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::setDataSizeLimitsForTest(ErrorString*,
-                                                     int maxTotal,
-                                                     int maxResource) {
+Response InspectorNetworkAgent::setDataSizeLimitsForTest(int maxTotal,
+                                                         int maxResource) {
   m_resourcesData->setResourcesDataSizeLimits(maxTotal, maxResource);
+  return Response::OK();
 }
 
-void InspectorNetworkAgent::getCertificate(
-    ErrorString*,
+Response InspectorNetworkAgent::getCertificate(
     const String& origin,
     std::unique_ptr<protocol::Array<String>>* certificate) {
   *certificate = protocol::Array<String>::create();
   RefPtr<SecurityOrigin> securityOrigin =
       SecurityOrigin::createFromString(origin);
   for (auto& resource : m_resourcesData->resources()) {
     RefPtr<SecurityOrigin> resourceOrigin =
         SecurityOrigin::create(resource->requestedURL());
     if (resourceOrigin->isSameSchemeHostPort(securityOrigin.get())) {
       for (auto& cert : resource->certificate())
         certificate->get()->addItem(base64Encode(cert.latin1()));
-      return;
+      return Response::OK();
     }
   }
+  return Response::OK();
 }
 
 void InspectorNetworkAgent::didCommitLoad(LocalFrame* frame,
                                           DocumentLoader* loader) {
   if (loader->frame() != m_inspectedFrames->root())
     return;
 
   if (m_state->booleanProperty(NetworkAgentState::cacheDisabled, false))
     memoryCache()->evictResources(MemoryCache::DoNotEvictUnusedPreloads);
 
@@ skipping 52 matching lines @@
       m_isRecalculatingStyle(false),
       m_removeFinishedReplayXHRTimer(
           this,
           &InspectorNetworkAgent::removeFinishedReplayXHRFired) {}
 
 bool InspectorNetworkAgent::shouldForceCORSPreflight() {
   return m_state->booleanProperty(NetworkAgentState::cacheDisabled, false);
 }
 
 }  // namespace blink