[DevTools] migrate InspectorPageAgent and InspectorMemoryAgent to new style

third_party/WebKit/Source/core/inspector/InspectorPageAgent.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 351 matching lines @@
       m_v8Session(v8Session),
       m_client(client),
       m_lastScriptIdentifier(0),
       m_enabled(false),
       m_reloading(false),
       m_inspectorResourceContentLoader(resourceContentLoader),
       m_resourceContentLoaderClientId(resourceContentLoader->createClientId()) {
 }
 
 void InspectorPageAgent::restore() {
-  ErrorString error;
   if (m_state->booleanProperty(PageAgentState::pageAgentEnabled, false))
-    enable(&error);
-  setBlockedEventsWarningThreshold(
-      &error, m_state->doubleProperty(
-                  PageAgentState::blockedEventsWarningThreshold, 0.0));
+    enable();
+  setBlockedEventsWarningThreshold(m_state->doubleProperty(
+      PageAgentState::blockedEventsWarningThreshold, 0.0));
   if (m_client) {
     String overlayMessage;
     m_state->getString(PageAgentState::overlayMessage, &overlayMessage);
     m_client->configureOverlay(
         m_state->booleanProperty(PageAgentState::overlaySuspended, false),
         overlayMessage);
   }
 }
 
-void InspectorPageAgent::enable(ErrorString*) {
+Response InspectorPageAgent::enable() {
   m_enabled = true;
   m_state->setBoolean(PageAgentState::pageAgentEnabled, true);
   m_instrumentingAgents->addInspectorPageAgent(this);
+  return Response::OK();
 }
 
-void InspectorPageAgent::disable(ErrorString*) {
+Response InspectorPageAgent::disable() {
   m_enabled = false;
   m_state->setBoolean(PageAgentState::pageAgentEnabled, false);
   m_state->remove(PageAgentState::pageAgentScriptsToEvaluateOnLoad);
   m_scriptToEvaluateOnLoadOnce = String();
   m_pendingScriptToEvaluateOnLoadOnce = String();
   m_instrumentingAgents->removeInspectorPageAgent(this);
   m_inspectorResourceContentLoader->cancel(m_resourceContentLoaderClientId);
 
-  stopScreencast(0);
-  configureOverlay(nullptr, false, String());
+  stopScreencast();
+  configureOverlay(false, String());
 
   finishReload();
+  return Response::OK();
 }
 
-void InspectorPageAgent::addScriptToEvaluateOnLoad(ErrorString*,
-                                                   const String& source,
-                                                   String* identifier) {
+Response InspectorPageAgent::addScriptToEvaluateOnLoad(const String& source,
+                                                       String* identifier) {
   protocol::DictionaryValue* scripts =
       m_state->getObject(PageAgentState::pageAgentScriptsToEvaluateOnLoad);
   if (!scripts) {
     std::unique_ptr<protocol::DictionaryValue> newScripts =
         protocol::DictionaryValue::create();
     scripts = newScripts.get();
     m_state->setObject(PageAgentState::pageAgentScriptsToEvaluateOnLoad,
                        std::move(newScripts));
   }
   // Assure we don't override existing ids -- m_lastScriptIdentifier could get
   // out of sync WRT actual scripts once we restored the scripts from the cookie
   // during navigation.
   do {
     *identifier = String::number(++m_lastScriptIdentifier);
   } while (scripts->get(*identifier));
   scripts->setString(*identifier, source);
+  return Response::OK();
 }
 
-void InspectorPageAgent::removeScriptToEvaluateOnLoad(
-    ErrorString* error,
+Response InspectorPageAgent::removeScriptToEvaluateOnLoad(
     const String& identifier) {
   protocol::DictionaryValue* scripts =
       m_state->getObject(PageAgentState::pageAgentScriptsToEvaluateOnLoad);
-  if (!scripts || !scripts->get(identifier)) {
-    *error = "Script not found";
-    return;
-  }
+  if (!scripts || !scripts->get(identifier))
+    return Response::Error("Script not found");
   scripts->remove(identifier);
+  return Response::OK();
 }
 
-void InspectorPageAgent::setAutoAttachToCreatedPages(ErrorString*,
-                                                     bool autoAttach) {
+Response InspectorPageAgent::setAutoAttachToCreatedPages(bool autoAttach) {
   m_state->setBoolean(PageAgentState::autoAttachToCreatedPages, autoAttach);
+  return Response::OK();
 }
 
-void InspectorPageAgent::reload(
-    ErrorString*,
-    const Maybe<bool>& optionalBypassCache,
-    const Maybe<String>& optionalScriptToEvaluateOnLoad) {
+Response InspectorPageAgent::reload(
+    Maybe<bool> optionalBypassCache,
+    Maybe<String> optionalScriptToEvaluateOnLoad) {
   m_pendingScriptToEvaluateOnLoadOnce =
       optionalScriptToEvaluateOnLoad.fromMaybe("");
   m_v8Session->setSkipAllPauses(true);
   m_reloading = true;
   FrameLoadType reloadType = FrameLoadTypeReload;
   if (optionalBypassCache.fromMaybe(false))
     reloadType = FrameLoadTypeReloadBypassingCache;
   else if (RuntimeEnabledFeatures::
                reloadwithoutSubResourceCacheRevalidationEnabled())
     reloadType = FrameLoadTypeReloadMainResource;
   m_inspectedFrames->root()->reload(reloadType,
                                     ClientRedirectPolicy::NotClientRedirect);
+  return Response::OK();
 }
 
-void InspectorPageAgent::navigate(ErrorString*,
-                                  const String& url,
-                                  String* outFrameId) {
+Response InspectorPageAgent::navigate(const String& url, String* outFrameId) {
   *outFrameId = frameId(m_inspectedFrames->root());
+  return Response::OK();
 }
 
 static void cachedResourcesForDocument(Document* document,
                                        HeapVector<Member<Resource>>& result,
                                        bool skipXHRs) {
   const ResourceFetcher::DocumentResourceMap& allResources =
       document->fetcher()->allResources();
   for (const auto& resource : allResources) {
     Resource* cachedResource = resource.value.get();
     if (!cachedResource)
@@ skipping 32 matching lines @@
   HeapVector<Member<Document>> loaders =
       InspectorPageAgent::importsForFrame(frame);
 
   cachedResourcesForDocument(rootDocument, result, skipXHRs);
   for (size_t i = 0; i < loaders.size(); ++i)
     cachedResourcesForDocument(loaders[i], result, skipXHRs);
 
   return result;
 }
 
-void InspectorPageAgent::getResourceTree(
-    ErrorString*,
+Response InspectorPageAgent::getResourceTree(
     std::unique_ptr<protocol::Page::FrameResourceTree>* object) {
   *object = buildObjectForFrameTree(m_inspectedFrames->root());
+  return Response::OK();
 }
 
 void InspectorPageAgent::finishReload() {
   if (!m_reloading)
     return;
   m_reloading = false;
   m_v8Session->setSkipAllPauses(false);
 }
 
 void InspectorPageAgent::getResourceContentAfterResourcesContentLoaded(
     const String& frameId,
     const String& url,
     std::unique_ptr<GetResourceContentCallback> callback) {
   LocalFrame* frame = IdentifiersFactory::frameById(m_inspectedFrames, frameId);
   if (!frame) {
-    callback->sendFailure("No frame for given id found");
+    callback->sendFailure(Response::Error("No frame for given id found"));
     return;
   }
   String content;
   bool base64Encoded;
   if (InspectorPageAgent::cachedResourceContent(
           InspectorPageAgent::cachedResource(frame, KURL(ParsedURLString, url)),
           &content, &base64Encoded))
     callback->sendSuccess(content, base64Encoded);
   else
-    callback->sendFailure("No resource with given URL found");
+    callback->sendFailure(Response::Error("No resource with given URL found"));
 }
 
 void InspectorPageAgent::getResourceContent(
     const String& frameId,
     const String& url,
     std::unique_ptr<GetResourceContentCallback> callback) {
   if (!m_enabled) {
-    callback->sendFailure("Agent is not enabled.");
+    callback->sendFailure(Response::Error("Agent is not enabled."));
     return;
   }
   m_inspectorResourceContentLoader->ensureResourcesContentLoaded(
       m_resourceContentLoaderClientId,
       WTF::bind(
           &InspectorPageAgent::getResourceContentAfterResourcesContentLoaded,
           wrapPersistent(this), frameId, url, passed(std::move(callback))));
 }
 
 void InspectorPageAgent::searchContentAfterResourcesContentLoaded(
     const String& frameId,
     const String& url,
     const String& query,
     bool caseSensitive,
     bool isRegex,
     std::unique_ptr<SearchInResourceCallback> callback) {
   LocalFrame* frame = IdentifiersFactory::frameById(m_inspectedFrames, frameId);
   if (!frame) {
-    callback->sendFailure("No frame for given id found");
+    callback->sendFailure(Response::Error("No frame for given id found"));
     return;
   }
   String content;
   bool base64Encoded;
   if (!InspectorPageAgent::cachedResourceContent(
           InspectorPageAgent::cachedResource(frame, KURL(ParsedURLString, url)),
           &content, &base64Encoded)) {
-    callback->sendFailure("No resource with given URL found");
+    callback->sendFailure(Response::Error("No resource with given URL found"));
     return;
   }
 
   auto matches = m_v8Session->searchInTextByLines(
       toV8InspectorStringView(content), toV8InspectorStringView(query),
       caseSensitive, isRegex);
   auto results = protocol::Array<
       v8_inspector::protocol::Debugger::API::SearchMatch>::create();
   for (size_t i = 0; i < matches.size(); ++i)
     results->addItem(std::move(matches[i]));
   callback->sendSuccess(std::move(results));
 }
 
 void InspectorPageAgent::searchInResource(
     const String& frameId,
     const String& url,
     const String& query,
-    const Maybe<bool>& optionalCaseSensitive,
-    const Maybe<bool>& optionalIsRegex,
+    Maybe<bool> optionalCaseSensitive,
+    Maybe<bool> optionalIsRegex,
     std::unique_ptr<SearchInResourceCallback> callback) {
   if (!m_enabled) {
-    callback->sendFailure("Agent is not enabled.");
+    callback->sendFailure(Response::Error("Agent is not enabled."));
     return;
   }
   m_inspectorResourceContentLoader->ensureResourcesContentLoaded(
       m_resourceContentLoaderClientId,
       WTF::bind(&InspectorPageAgent::searchContentAfterResourcesContentLoaded,
                 wrapPersistent(this), frameId, url, query,
                 optionalCaseSensitive.fromMaybe(false),
                 optionalIsRegex.fromMaybe(false), passed(std::move(callback))));
 }
 
-void InspectorPageAgent::setDocumentContent(ErrorString* errorString,
-                                            const String& frameId,
-                                            const String& html) {
+Response InspectorPageAgent::setDocumentContent(const String& frameId,
+                                                const String& html) {
   LocalFrame* frame = IdentifiersFactory::frameById(m_inspectedFrames, frameId);
-  if (!frame) {
-    *errorString = "No frame for given id found";
-    return;
-  }
+  if (!frame)
+    return Response::Error("No frame for given id found");
 
   Document* document = frame->document();
-  if (!document) {
-    *errorString = "No Document instance to set HTML for";
-    return;
-  }
+  if (!document)
+    return Response::Error("No Document instance to set HTML for");
   DOMPatchSupport::patchDocument(*document, html);
+  return Response::OK();
 }
 
 void InspectorPageAgent::didClearDocumentOfWindowObject(LocalFrame* frame) {
   if (!frontend())
     return;
 
   protocol::DictionaryValue* scripts =
       m_state->getObject(PageAgentState::pageAgentScriptsToEvaluateOnLoad);
   if (scripts) {
     for (size_t i = 0; i < scripts->size(); ++i) {
@@ skipping 177 matching lines @@
       continue;
     if (!childrenArray)
       childrenArray =
           protocol::Array<protocol::Page::FrameResourceTree>::create();
     childrenArray->addItem(buildObjectForFrameTree(toLocalFrame(child)));
   }
   result->setChildFrames(std::move(childrenArray));
   return result;
 }
 
-void InspectorPageAgent::startScreencast(ErrorString*,
-                                         const Maybe<String>& format,
-                                         const Maybe<int>& quality,
-                                         const Maybe<int>& maxWidth,
-                                         const Maybe<int>& maxHeight,
-                                         const Maybe<int>& everyNthFrame) {
+Response InspectorPageAgent::startScreencast(Maybe<String> format,
+                                             Maybe<int> quality,
+                                             Maybe<int> maxWidth,
+                                             Maybe<int> maxHeight,
+                                             Maybe<int> everyNthFrame) {
   m_state->setBoolean(PageAgentState::screencastEnabled, true);
+  return Response::OK();
 }
 
-void InspectorPageAgent::stopScreencast(ErrorString*) {
+Response InspectorPageAgent::stopScreencast() {
   m_state->setBoolean(PageAgentState::screencastEnabled, false);
+  return Response::OK();
 }
 
-void InspectorPageAgent::configureOverlay(ErrorString*,
-                                          const Maybe<bool>& suspended,
-                                          const Maybe<String>& message) {
+Response InspectorPageAgent::configureOverlay(Maybe<bool> suspended,
+                                              Maybe<String> message) {
   m_state->setBoolean(PageAgentState::overlaySuspended,
                       suspended.fromMaybe(false));
   m_state->setString(PageAgentState::overlaySuspended,
                      message.fromMaybe(String()));
   if (m_client)
     m_client->configureOverlay(suspended.fromMaybe(false),
                                message.fromMaybe(String()));
+  return Response::OK();
 }
 
-void InspectorPageAgent::setBlockedEventsWarningThreshold(ErrorString*,
-                                                          double threshold) {
+Response InspectorPageAgent::setBlockedEventsWarningThreshold(
+    double threshold) {
   m_state->setDouble(PageAgentState::blockedEventsWarningThreshold, threshold);
   FrameHost* host = m_inspectedFrames->root()->host();
   if (!host)
-    return;
+    return Response::Error("Host not found");
   host->settings().setBlockedMainThreadEventsWarningThreshold(threshold);
+  return Response::OK();
 }
 
-void InspectorPageAgent::getLayoutMetrics(
-    ErrorString*,
+Response InspectorPageAgent::getLayoutMetrics(
     std::unique_ptr<protocol::Page::LayoutViewport>* outLayoutViewport,
     std::unique_ptr<protocol::Page::VisualViewport>* outVisualViewport) {
   LocalFrame* mainFrame = m_inspectedFrames->root();
   VisualViewport& visualViewport = mainFrame->host()->visualViewport();
 
   mainFrame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   IntRect visibleContents = mainFrame->view()->visibleContentRect();
   *outLayoutViewport = protocol::Page::LayoutViewport::create()
                            .setPageX(visibleContents.x())
@@ skipping 13 matching lines @@
   *outVisualViewport =
       protocol::Page::VisualViewport::create()
           .setOffsetX(adjustScrollForAbsoluteZoom(visibleRect.x(), pageZoom))
           .setOffsetY(adjustScrollForAbsoluteZoom(visibleRect.y(), pageZoom))
           .setPageX(adjustScrollForAbsoluteZoom(pageOffset.width(), pageZoom))
           .setPageY(adjustScrollForAbsoluteZoom(pageOffset.height(), pageZoom))
           .setClientWidth(visibleRect.width() - scrollbarWidth)
           .setClientHeight(visibleRect.height() - scrollbarHeight)
           .setScale(scale)
           .build();
+  return Response::OK();
 }
 
 DEFINE_TRACE(InspectorPageAgent) {
   visitor->trace(m_inspectedFrames);
   visitor->trace(m_inspectorResourceContentLoader);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink