[DevTools] Roll inspector_protocol (Chromium)

Upstream PR:
Introduce a crdtp/dispatch.{h,cc} library.
https://chromium-review.googlesource.com/c/deps/inspector_protocol/+/1974680

New Rev: 8c2064ea99cffdb5647760ad3953c43e612e07fc

Notable downstream changes:
- ChromeDevToolsManagerDelegate::HandleCommand no longer carries
  a method. Reason being, the shallow parser (crdtp::Dispatchable)
  should be efficient enough to parse an incoming message a couple
  of times, e.g. once for the content layer and once for the
  embedder, and if we felt differently then we'd quite possibly
  want to carry more than just the method - e.g., we'd want to also
  pass the params. Anyway, for now simplifying this interface.
- crdtp::FrontendChannel::FallThrough; here, it's advantagueous
  to keep the method around, but now it's a crdtp::span. This is
  much better than const std::string& because the generated code
  knows exactly which method is going to fall through and we
  can pass a C++ string literal via this span.
- The crdtp/dispatch library presents a somewhat different surface
  between the UberDispatcher and the session implementations.
  The session implementations are responsible for creating a
  crdtp::Dispatchable instance (the shallow parser) which
  it then hands to the dispatcher for dispatching. Rather than
  querying for whether it can dispatch and then doing it,
  the result of the Dispatch indicates whether a method was
  found and can be executed. There's no more need to instantiate
  protocol::Value in a devtools session class.
- Since the dispatch library uses crdtp::span to represent
  method names, we no longer need to reference platform specific
  routines for finding strings and making substrings. As a result,
  v8_inspector_string.h is losing a few more methods
  (and same for base_string_adapter_h.template).
- crdtp::DispatchResponse (also known as protocol::Response) has
  some renames for consistency (
  Response::Error -> Response::SeverError,
  Response::OK -> Response::Success). Touches all domain handlers
  but is mechanical.
- All protocol error messages, such as the parameters passed
  to DispatchResponse::ServerError are required to be UTF8 strings,
  even for Blink, so when code generates them as WTF::String,
  we convert them to std::string using WTF::String::Utf8()
  before passing them to DispatchResponse::ServerError.
- We're better about checking messages and sending errors when we
  can't parse them - esp. we no longer drop messages on the floor
  if we can't make sense of them; the LOG statements are gone,
  because we can either send an error or assume that we've
  previously parsed the message elsewhere and put a DCHECK (e.g.,
  a message received by blink has always been shallow-parsed by the
  browser before).
- DevToolsAgentHost::DispatchProtocolMessage no longer has a boolean
  return value. Reason being, it's not well defined what the
  boolean should indicate. If we reject the message and send
  an error, arguably we've also handled it. And of course, we
  always do that (now). So it's not useful to generate or check
  this return value, and there is only one DCHECK on it currently,
  which is also not covered by tests.
- content::DevToolsSession uses binary searches to match method names
  (e.g. in ShouldSendOnIO).
  This is because I've switched the method names to span, and
  implemented similar searches for the dispatching library, so
  it's best to be consistent. It will also scale better if we add
  more methods.
- The additional unittests added to the CRDTP library upstream cover
  shallow parsing, dispatching, etc. and are now also part of
  the content_unittests.
- Improves Android binary size by about 36k, by reducing code
  duplication. There's now just one UberDispatcher, for example,
  as opposed to one for blink, one for content, one for headless,
  one for chromium, ...
- Speeds up execution by 1-2% (based on internal measurements),
  because message serialization no longer takes a detour via
  protocol::Value.

Change-Id: I422fe527d6f8a6ffb098b3992728ecba408b571f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2047966
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Ganggui Tang <gogerald@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Reviewed-by: Leonard Grey <lgrey@chromium.org>
Commit-Queue: Johannes Henkel <johannes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#750284}

chrome/browser/devtools/chrome_devtools_manager_delegate.cc

@@ -118,7 +118,6 @@ void ChromeDevToolsManagerDelegate::Inspect(
 
 void ChromeDevToolsManagerDelegate::HandleCommand(
     content::DevToolsAgentHostClientChannel* channel,
-    const std::string& method,
     base::span<const uint8_t> message,
     NotHandledCallback callback) {
   auto it = sessions_.find(channel);
@@ -129,7 +128,7 @@ void ChromeDevToolsManagerDelegate::HandleCommand(
     NOTREACHED();
     return;
   }
-  it->second->HandleCommand(method, message, std::move(callback));
+  it->second->HandleCommand(message, std::move(callback));
 }
 
 std::string ChromeDevToolsManagerDelegate::GetTargetType(

chrome/browser/devtools/chrome_devtools_manager_delegate.h

@@ -62,7 +62,6 @@ class ChromeDevToolsManagerDelegate : public content::DevToolsManagerDelegate {
   // content::DevToolsManagerDelegate implementation.
   void Inspect(content::DevToolsAgentHost* agent_host) override;
   void HandleCommand(content::DevToolsAgentHostClientChannel* channel,
-                     const std::string& method,
                      base::span<const uint8_t> message,
                      NotHandledCallback callback) override;
   std::string GetTargetType(content::WebContents* web_contents) override;

chrome/browser/devtools/chrome_devtools_session.cc

@@ -15,6 +15,7 @@
 #include "content/public/browser/devtools_agent_host_client.h"
 #include "content/public/browser/devtools_agent_host_client_channel.h"
 #include "content/public/browser/devtools_manager_delegate.h"
+#include "third_party/inspector_protocol/crdtp/dispatch.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/devtools/protocol/window_manager_handler.h"
@@ -49,44 +50,38 @@ ChromeDevToolsSession::ChromeDevToolsSession(
 ChromeDevToolsSession::~ChromeDevToolsSession() = default;
 
 void ChromeDevToolsSession::HandleCommand(
-    const std::string& method,
     base::span<const uint8_t> message,
     content::DevToolsManagerDelegate::NotHandledCallback callback) {
-  if (!dispatcher_.canDispatch(method)) {
+  crdtp::Dispatchable dispatchable(crdtp::SpanFrom(message));
+  DCHECK(dispatchable.ok());  // Checked by content::DevToolsSession.
+  crdtp::UberDispatcher::DispatchResult dispatched =
+      dispatcher_.Dispatch(dispatchable);
+  if (!dispatched.MethodFound()) {
     std::move(callback).Run(message);
     return;
   }
-
-  int call_id;
-  std::string unused;
-  std::unique_ptr<protocol::DictionaryValue> value =
-      protocol::DictionaryValue::cast(protocol::Value::parseBinary(
-          reinterpret_cast<const uint8_t*>(message.data()), message.size()));
-  if (!dispatcher_.parseCommand(value.get(), &call_id, &unused))
-    return;
-  pending_commands_[call_id] = std::move(callback);
-  dispatcher_.dispatch(call_id, method, std::move(value),
-                       crdtp::SpanFrom(message));
+  pending_commands_[dispatchable.CallId()] = std::move(callback);
+  dispatched.Run();
 }
 
 // The following methods handle responses or notifications coming from
 // the browser to the client.
-void ChromeDevToolsSession::sendProtocolResponse(
+void ChromeDevToolsSession::SendProtocolResponse(
     int call_id,
     std::unique_ptr<protocol::Serializable> message) {
   pending_commands_.erase(call_id);
   client_channel_->DispatchProtocolMessageToClient(message->Serialize());
 }
 
-void ChromeDevToolsSession::sendProtocolNotification(
+void ChromeDevToolsSession::SendProtocolNotification(
     std::unique_ptr<protocol::Serializable> message) {
   client_channel_->DispatchProtocolMessageToClient(message->Serialize());
 }
 
-void ChromeDevToolsSession::flushProtocolNotifications() {}
+void ChromeDevToolsSession::FlushProtocolNotifications() {}
 
-void ChromeDevToolsSession::fallThrough(int call_id,
-                                        const std::string& method,
+void ChromeDevToolsSession::FallThrough(int call_id,
+                                        crdtp::span<uint8_t> method,
                                         crdtp::span<uint8_t> message) {
   auto callback = std::move(pending_commands_[call_id]);
   pending_commands_.erase(call_id);

chrome/browser/devtools/chrome_devtools_session.h

@@ -32,7 +32,6 @@ class ChromeDevToolsSession : public protocol::FrontendChannel {
   ~ChromeDevToolsSession() override;
 
   void HandleCommand(
-      const std::string& method,
       base::span<const uint8_t> message,
       content::DevToolsManagerDelegate::NotHandledCallback callback);
 
@@ -40,14 +39,14 @@ class ChromeDevToolsSession : public protocol::FrontendChannel {
 
  private:
   // protocol::FrontendChannel:
-  void sendProtocolResponse(
+  void SendProtocolResponse(
       int call_id,
       std::unique_ptr<protocol::Serializable> message) override;
-  void sendProtocolNotification(
+  void SendProtocolNotification(
       std::unique_ptr<protocol::Serializable> message) override;
-  void flushProtocolNotifications() override;
-  void fallThrough(int call_id,
-                   const std::string& method,
+  void FlushProtocolNotifications() override;
+  void FallThrough(int call_id,
+                   crdtp::span<uint8_t> method,
                    crdtp::span<uint8_t> message) override;
 
   base::flat_map<int, content::DevToolsManagerDelegate::NotHandledCallback>

chrome/browser/devtools/protocol/browser_handler.cc

@@ -80,10 +80,10 @@ Response BrowserHandler::GetWindowForTarget(
   auto host =
       content::DevToolsAgentHost::GetForId(target_id.fromMaybe(target_id_));
   if (!host)
-    return Response::Error("No target with given id");
+    return Response::ServerError("No target with given id");
   content::WebContents* web_contents = host->GetWebContents();
   if (!web_contents)
-    return Response::Error("No web contents in the target");
+    return Response::ServerError("No web contents in the target");
 
   Browser* browser = nullptr;
   for (auto* b : *BrowserList::GetInstance()) {
@@ -92,12 +92,12 @@ Response BrowserHandler::GetWindowForTarget(
       browser = b;
   }
   if (!browser)
-    return Response::Error("Browser window not found");
+    return Response::ServerError("Browser window not found");
 
   BrowserWindow* window = browser->window();
   *out_window_id = browser->session_id().id();
   *out_bounds = GetBrowserWindowBounds(window);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::GetWindowBounds(
@@ -105,10 +105,10 @@ Response BrowserHandler::GetWindowBounds(
     std::unique_ptr<protocol::Browser::Bounds>* out_bounds) {
   BrowserWindow* window = GetBrowserWindow(window_id);
   if (!window)
-    return Response::Error("Browser window not found");
+    return Response::ServerError("Browser window not found");
 
   *out_bounds = GetBrowserWindowBounds(window);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::Close() {
@@ -118,7 +118,7 @@ Response BrowserHandler::Close() {
           ChromeDevToolsManagerDelegate::GetInstance()->BrowserCloseRequested();
         chrome::ExitIgnoreUnloadHandlers();
       }));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::SetWindowBounds(
@@ -126,7 +126,7 @@ Response BrowserHandler::SetWindowBounds(
     std::unique_ptr<protocol::Browser::Bounds> window_bounds) {
   BrowserWindow* window = GetBrowserWindow(window_id);
   if (!window)
-    return Response::Error("Browser window not found");
+    return Response::ServerError("Browser window not found");
   gfx::Rect bounds = window->GetBounds();
   const bool set_bounds = window_bounds->HasLeft() || window_bounds->HasTop() ||
                           window_bounds->HasWidth() ||
@@ -140,14 +140,14 @@ Response BrowserHandler::SetWindowBounds(
 
   const std::string window_state = window_bounds->GetWindowState("normal");
   if (set_bounds && window_state != "normal") {
-    return Response::Error(
+    return Response::ServerError(
         "The 'minimized', 'maximized' and 'fullscreen' states cannot be "
         "combined with 'left', 'top', 'width' or 'height'");
   }
 
   if (window_state == "fullscreen") {
     if (window->IsMinimized()) {
-      return Response::Error(
+      return Response::ServerError(
           "To make minimized window fullscreen, "
           "restore it to normal state first.");
     }
@@ -155,14 +155,14 @@ Response BrowserHandler::SetWindowBounds(
         GURL(), EXCLUSIVE_ACCESS_BUBBLE_TYPE_NONE, display::kInvalidDisplayId);
   } else if (window_state == "maximized") {
     if (window->IsMinimized() || window->IsFullscreen()) {
-      return Response::Error(
+      return Response::ServerError(
           "To maximize a minimized or fullscreen "
           "window, restore it to normal state first.");
     }
     window->Maximize();
   } else if (window_state == "minimized") {
     if (window->IsFullscreen()) {
-      return Response::Error(
+      return Response::ServerError(
           "To minimize a fullscreen window, restore it to normal "
           "state first.");
     }
@@ -180,7 +180,7 @@ Response BrowserHandler::SetWindowBounds(
     NOTREACHED();
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response BrowserHandler::SetDockTile(
@@ -191,5 +191,5 @@ protocol::Response BrowserHandler::SetDockTile(
     reps.emplace_back(image.fromJust().bytes(), 1);
   DevToolsDockTile::Update(label.fromMaybe(std::string()),
                            !reps.empty() ? gfx::Image(reps) : gfx::Image());
-  return Response::OK();
+  return Response::Success();
 }

chrome/browser/devtools/protocol/cast_handler.cc

@@ -89,7 +89,7 @@ Response CastHandler::SetSinkToUse(const std::string& in_sink_name) {
       ->set_start_presentation_cb(
           base::BindRepeating(&CastHandler::StartPresentation,
                               weak_factory_.GetWeakPtr(), in_sink_name));
-  return Response::OK();
+  return Response::Success();
 }
 
 void CastHandler::StartTabMirroring(
@@ -98,7 +98,7 @@ void CastHandler::StartTabMirroring(
   EnsureInitialized();
   const media_router::MediaSink::Id& sink_id = GetSinkIdByName(in_sink_name);
   if (sink_id.empty()) {
-    callback->sendFailure(Response::Error("Sink not found"));
+    callback->sendFailure(Response::ServerError("Sink not found"));
     return;
   }
 
@@ -119,19 +119,19 @@ Response CastHandler::StopCasting(const std::string& in_sink_name) {
   EnsureInitialized();
   const media_router::MediaSink::Id& sink_id = GetSinkIdByName(in_sink_name);
   if (sink_id.empty())
-    return Response::Error("Sink not found");
+    return Response::ServerError("Sink not found");
   const MediaRoute::Id& route_id = GetRouteIdForSink(sink_id);
   if (route_id.empty())
-    return Response::Error("Route not found");
+    return Response::ServerError("Route not found");
   router_->TerminateRoute(route_id);
   initiated_routes_.erase(route_id);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response CastHandler::Enable(protocol::Maybe<std::string> in_presentation_url) {
   EnsureInitialized();
   StartObservingForSinks(std::move(in_presentation_url));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response CastHandler::Disable() {
@@ -140,7 +140,7 @@ Response CastHandler::Disable() {
   issues_observer_.reset();
   for (const MediaRoute::Id& route_id : initiated_routes_)
     router_->TerminateRoute(route_id);
-  return Response::OK();
+  return Response::Success();
 }
 
 void CastHandler::OnResultsUpdated(
@@ -266,7 +266,7 @@ void CastHandler::OnTabMirroringStarted(
     initiated_routes_.insert(result.route()->media_route_id());
     callback->sendSuccess();
   } else {
-    callback->sendFailure(Response::Error(result.error()));
+    callback->sendFailure(Response::ServerError(result.error()));
   }
 }
 

chrome/browser/devtools/protocol/cast_handler_unittest.cc

@@ -93,7 +93,7 @@ class CastHandlerTest : public ChromeRenderViewHostTestHarness {
 
 TEST_F(CastHandlerTest, SetSinkToUse) {
   sinks_observer_->OnSinksUpdated({sink1, sink2}, {});
-  EXPECT_TRUE(handler_->SetSinkToUse(kSinkName1).isSuccess());
+  EXPECT_TRUE(handler_->SetSinkToUse(kSinkName1).IsSuccess());
 
   const std::string presentation_url("https://example.com/");
   content::PresentationRequest request(content::GlobalFrameRoutingId(),
@@ -154,13 +154,12 @@ TEST_F(CastHandlerTest, StopCasting) {
   sinks_observer_->OnSinksUpdated({sink1, sink2}, {});
   routes_observer_->OnRoutesUpdated({Route1()}, {});
   EXPECT_CALL(*router_, TerminateRoute(kRouteId1));
-  EXPECT_TRUE(handler_->StopCasting(kSinkName1).isSuccess());
+  EXPECT_TRUE(handler_->StopCasting(kSinkName1).IsSuccess());
 }
 
 TEST_F(CastHandlerTest, StopCastingWithInvalidName) {
   sinks_observer_->OnSinksUpdated({sink1, sink2}, {});
   routes_observer_->OnRoutesUpdated({Route1()}, {});
   // Attempting to stop casting to a sink without a route should fail.
-  EXPECT_EQ(protocol::Response::kError,
-            handler_->StopCasting(kSinkName2).status());
+  EXPECT_TRUE(handler_->StopCasting(kSinkName2).IsError());
 }

chrome/browser/devtools/protocol/page_handler.cc

@@ -45,9 +45,9 @@ protocol::Response PageHandler::Disable() {
 
 protocol::Response PageHandler::SetAdBlockingEnabled(bool enabled) {
   if (!enabled_)
-    return protocol::Response::Error("Page domain is disabled.");
+    return protocol::Response::ServerError("Page domain is disabled.");
   ToggleAdBlocking(enabled);
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 void PageHandler::GetInstallabilityErrors(
@@ -58,7 +58,7 @@ void PageHandler::GetInstallabilityErrors(
                      : nullptr;
   if (!manager) {
     callback->sendFailure(
-        protocol::Response::Error("Unable to fetch errors for target"));
+        protocol::Response::ServerError("Unable to fetch errors for target"));
     return;
   }
   manager->GetAllErrors(base::BindOnce(&PageHandler::GotInstallabilityErrors,
@@ -100,7 +100,7 @@ void PageHandler::GetManifestIcons(
 
   if (!manager) {
     callback->sendFailure(
-        protocol::Response::Error("Unable to fetch icons for target"));
+        protocol::Response::ServerError("Unable to fetch icons for target"));
     return;
   }
 

chrome/browser/devtools/protocol/target_handler.cc

@@ -51,7 +51,7 @@ protocol::Response TargetHandler::SetRemoteLocations(
         locations) {
   remote_locations_.clear();
   if (!locations)
-    return protocol::Response::OK();
+    return protocol::Response::Success();
 
   for (const auto& location : *locations) {
     remote_locations_.insert(
@@ -62,7 +62,7 @@ protocol::Response TargetHandler::SetRemoteLocations(
       ChromeDevToolsManagerDelegate::GetInstance();
   if (delegate)
     delegate->UpdateDeviceDiscovery();
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response TargetHandler::CreateTarget(
@@ -80,7 +80,7 @@ protocol::Response TargetHandler::CreateTarget(
     profile =
         DevToolsBrowserContextManager::GetInstance().GetProfileById(profile_id);
     if (!profile) {
-      return protocol::Response::Error(
+      return protocol::Response::ServerError(
           "Failed to find browser context with id " + profile_id);
     }
   }
@@ -103,7 +103,7 @@ protocol::Response TargetHandler::CreateTarget(
 
   bool explicit_old_window = !new_window.fromMaybe(true);
   if (explicit_old_window && !target_browser) {
-    return protocol::Response::Error(
+    return protocol::Response::ServerError(
         "Failed to open new tab - "
         "no browser is open");
   }
@@ -114,10 +114,10 @@ protocol::Response TargetHandler::CreateTarget(
       create_in_background, target_browser);
   Navigate(&params);
   if (!params.navigated_or_inserted_contents)
-    return protocol::Response::Error("Failed to open a new tab");
+    return protocol::Response::ServerError("Failed to open a new tab");
 
   *out_target_id = content::DevToolsAgentHost::GetOrCreateFor(
                        params.navigated_or_inserted_contents)
                        ->GetId();
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }

chrome/browser/devtools/protocol/window_manager_handler.cc

@@ -18,13 +18,13 @@ WindowManagerHandler::~WindowManagerHandler() = default;
 protocol::Response WindowManagerHandler::EnterOverviewMode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   bool success = ash::Shell::Get()->overview_controller()->StartOverview();
-  return success ? protocol::Response::OK()
-                 : protocol::Response::Error("Overview failed");
+  return success ? protocol::Response::Success()
+                 : protocol::Response::ServerError("Overview failed");
 }
 
 protocol::Response WindowManagerHandler::ExitOverviewMode() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   bool success = ash::Shell::Get()->overview_controller()->EndOverview();
-  return success ? protocol::Response::OK()
-                 : protocol::Response::Error("Overview failed");
+  return success ? protocol::Response::Success()
+                 : protocol::Response::ServerError("Overview failed");
 }

components/autofill_assistant/browser/devtools/devtools_client.cc

@@ -104,9 +104,8 @@ void DevtoolsClient::SendMessageWithParams(
   std::string json_message;
   base::JSONWriter::Write(message, &json_message);
 
-  bool success = agent_host_->DispatchProtocolMessage(
+  agent_host_->DispatchProtocolMessage(
       this, base::as_bytes(base::make_span(json_message)));
-  DCHECK(success);
 }
 
 void DevtoolsClient::RegisterEventHandler(

components/ui_devtools/css_agent.cc

@@ -147,8 +147,8 @@ std::string BuildStylesheetUId(int node_id, int stylesheet_id) {
 }
 
 Response NodeNotFoundError(int node_id) {
-  return Response::Error("Node with id=" + std::to_string(node_id) +
-                         " not found");
+  return Response::ServerError("Node with id=" + base::NumberToString(node_id) +
+                               " not found");
 }
 
 Response ParseProperties(const std::string& style_text,
@@ -158,13 +158,14 @@ Response ParseProperties(const std::string& style_text,
       style_text, ":;", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
 
   if (tokens.size() < 2 || tokens.size() % 2 != 0)
-    return Response::Error("Need both a property name and value.");
+    return Response::ServerError("Need both a property name and value.");
 
   for (size_t i = 0; i < tokens.size() - 1; i += 2) {
     const std::string& property = tokens.at(i);
     int value;
     if (!base::StringToInt(tokens.at(i + 1), &value)) {
-      return Response::Error("Unable to parse value for property=" + property);
+      return Response::ServerError("Unable to parse value for property=" +
+                                   property);
     }
 
     if (property == kHeight)
@@ -178,9 +179,9 @@ Response ParseProperties(const std::string& style_text,
     else if (property == kVisibility)
       *visible = std::max(0, value) == 1;
     else
-      return Response::Error("Unsupported property=" + property);
+      return Response::ServerError("Unsupported property=" + property);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 std::unique_ptr<CSS::CSSStyleSheetHeader> BuildObjectForStyleSheetInfo(
@@ -210,12 +211,12 @@ CSSAgent::~CSSAgent() {
 
 Response CSSAgent::enable() {
   dom_agent_->AddObserver(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response CSSAgent::disable() {
   dom_agent_->RemoveObserver(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response CSSAgent::getMatchedStylesForNode(
@@ -225,7 +226,7 @@ Response CSSAgent::getMatchedStylesForNode(
   if (!ui_element)
     return NodeNotFoundError(node_id);
   *matched_css_rules = BuildMatchedStyles(ui_element);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response CSSAgent::getStyleSheetText(const protocol::String& style_sheet_id,
@@ -236,19 +237,19 @@ Response CSSAgent::getStyleSheetText(const protocol::String& style_sheet_id,
       style_sheet_id, "_", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (ids.size() < 2 || !base::StringToInt(ids[0], &node_id) ||
       !base::StringToInt(ids[1], &stylesheet_id))
-    return Response::Error("Invalid stylesheet id");
+    return Response::ServerError("Invalid stylesheet id");
 
   UIElement* ui_element = dom_agent_->GetElementFromNodeId(node_id);
   if (!ui_element)
-    return Response::Error("Node id not found");
+    return Response::ServerError("Node id not found");
 
   auto sources = ui_element->GetSources();
   if (static_cast<int>(sources.size()) <= stylesheet_id)
-    return Response::Error("Stylesheet id not found");
+    return Response::ServerError("Stylesheet id not found");
 
   if (GetSourceCode(sources[stylesheet_id].path_, result))
-    return Response::OK();
-  return Response::Error("Could not read source file");
+    return Response::Success();
+  return Response::ServerError("Could not read source file");
 }
 
 Response CSSAgent::setStyleTexts(
@@ -264,12 +265,12 @@ Response CSSAgent::setStyleTexts(
                           base::SPLIT_WANT_NONEMPTY);
     if (ids.size() < 2 || !base::StringToInt(ids[0], &node_id) ||
         !base::StringToInt(ids[1], &stylesheet_id))
-      return Response::Error("Invalid stylesheet id");
+      return Response::ServerError("Invalid stylesheet id");
 
     UIElement* ui_element = dom_agent_->GetElementFromNodeId(node_id);
 
     if (!ui_element)
-      return Response::Error("Node id not found");
+      return Response::ServerError("Node id not found");
     // Handle setting properties from metadata for View.
     if (ui_element->type() == VIEW)
       ui_element->SetPropertiesFromString(edit->getText());
@@ -281,7 +282,7 @@ Response CSSAgent::setStyleTexts(
 
     Response response(
         ParseProperties(edit->getText(), &updated_bounds, &visible));
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
 
     if (!SetPropertiesForUIElement(ui_element, updated_bounds, visible))
@@ -293,7 +294,7 @@ Response CSSAgent::setStyleTexts(
                                      .properties_));
   }
   *result = std::move(updated_styles);
-  return Response::OK();
+  return Response::Success();
 }
 
 void CSSAgent::OnElementBoundsChanged(UIElement* ui_element) {

components/ui_devtools/css_agent_unittest.cc

@@ -110,7 +110,7 @@ class CSSAgentTest : public testing::Test {
     edits->emplace_back(std::move(edit));
     std::unique_ptr<StyleArray> output;
     auto response = css_agent_->setStyleTexts(std::move(edits), &output);
-    return {response.isSuccess(), std::move(output)};
+    return {response.IsSuccess(), std::move(output)};
   }
 
   std::string GetValueForProperty(protocol::CSS::CSSStyle* style,
@@ -134,7 +134,7 @@ class CSSAgentTest : public testing::Test {
     std::string output;
     auto response = css_agent_->getStyleSheetText(
         BuildStylesheetUId(element()->node_id(), 0), &output);
-    return {response.isSuccess(), output};
+    return {response.IsSuccess(), output};
   }
 
   CSSAgent* css_agent() { return css_agent_.get(); }

components/ui_devtools/devtools_base_agent.h

@@ -38,12 +38,14 @@ class UiDevToolsBaseAgent : public UiDevToolsAgent,
 
   // Common methods between all generated Backends, subclasses may
   // choose to override them (but not necessary).
-  protocol::Response enable() override { return protocol::Response::OK(); }
+  protocol::Response enable() override { return protocol::Response::Success(); }
 
-  protocol::Response disable() override { return protocol::Response::OK(); }
+  protocol::Response disable() override {
+    return protocol::Response::Success();
+  }
 
  protected:
-  UiDevToolsBaseAgent() {}
+  UiDevToolsBaseAgent() = default;
   typename DomainMetainfo::FrontendClass* frontend() const {
     return frontend_.get();
   }

components/ui_devtools/devtools_client.cc

@@ -5,6 +5,7 @@
 #include "components/ui_devtools/devtools_client.h"
 
 #include "components/ui_devtools/devtools_server.h"
+#include "third_party/inspector_protocol/crdtp/dispatch.h"
 #include "third_party/inspector_protocol/crdtp/json.h"
 
 namespace ui_devtools {
@@ -34,15 +35,25 @@ void UiDevToolsClient::Dispatch(const std::string& json) {
   std::vector<uint8_t> cbor;
   crdtp::Status status =
       crdtp::json::ConvertJSONToCBOR(crdtp::SpanFrom(json), &cbor);
-  LOG_IF(ERROR, !status.ok()) << status.ToASCIIString();
-
-  int call_id;
-  std::string method;
-  std::unique_ptr<protocol::Value> protocolCommand =
-      protocol::Value::parseBinary(cbor.data(), cbor.size());
-  if (dispatcher_.parseCommand(protocolCommand.get(), &call_id, &method)) {
-    dispatcher_.dispatch(call_id, method, std::move(protocolCommand),
-                         crdtp::SpanFrom(cbor));
+  if (!status.ok()) {
+    dispatcher_.channel()->SendProtocolNotification(
+        crdtp::CreateErrorNotification(
+            crdtp::DispatchResponse::ParseError(status.ToASCIIString())));
+    return;
+  }
+  crdtp::Dispatchable dispatchable(crdtp::SpanFrom(cbor));
+  if (dispatchable.ok()) {
+    dispatcher_.Dispatch(dispatchable).Run();
+    return;
+  }
+  if (dispatchable.HasCallId()) {
+    dispatcher_.channel()->SendProtocolResponse(
+        dispatchable.CallId(),
+        crdtp::CreateErrorResponse(dispatchable.CallId(),
+                                   dispatchable.DispatchError()));
+  } else {
+    dispatcher_.channel()->SendProtocolNotification(
+        crdtp::CreateErrorNotification(dispatchable.DispatchError()));
   }
 }
 
@@ -71,27 +82,27 @@ void UiDevToolsClient::MaybeSendProtocolResponseOrNotification(
   std::string json;
   crdtp::Status status = crdtp::json::ConvertCBORToJSON(
       crdtp::SpanFrom(message->Serialize()), &json);
-  LOG_IF(ERROR, !status.ok()) << status.ToASCIIString();
+  DCHECK(status.ok());  // CBOR was generated by Chrome, so we expect it's ok.
   server_->SendOverWebSocket(connection_id_, base::StringPiece(json));
 }
 
-void UiDevToolsClient::sendProtocolResponse(
+void UiDevToolsClient::SendProtocolResponse(
     int callId,
     std::unique_ptr<protocol::Serializable> message) {
   MaybeSendProtocolResponseOrNotification(std::move(message));
 }
 
-void UiDevToolsClient::sendProtocolNotification(
+void UiDevToolsClient::SendProtocolNotification(
     std::unique_ptr<protocol::Serializable> message) {
   MaybeSendProtocolResponseOrNotification(std::move(message));
 }
 
-void UiDevToolsClient::flushProtocolNotifications() {
+void UiDevToolsClient::FlushProtocolNotifications() {
   NOTIMPLEMENTED();
 }
 
-void UiDevToolsClient::fallThrough(int call_id,
-                                   const std::string& method,
+void UiDevToolsClient::FallThrough(int call_id,
+                                   crdtp::span<uint8_t> method,
                                    crdtp::span<uint8_t> message) {
   NOTIMPLEMENTED();
 }

components/ui_devtools/devtools_client.h

@@ -42,14 +42,14 @@ class UI_DEVTOOLS_EXPORT UiDevToolsClient : public protocol::FrontendChannel {
       std::unique_ptr<protocol::Serializable> message);
 
   // protocol::FrontendChannel
-  void sendProtocolResponse(
+  void SendProtocolResponse(
       int callId,
       std::unique_ptr<protocol::Serializable> message) override;
-  void sendProtocolNotification(
+  void SendProtocolNotification(
       std::unique_ptr<protocol::Serializable> message) override;
-  void flushProtocolNotifications() override;
-  void fallThrough(int call_id,
-                   const std::string& method,
+  void FlushProtocolNotifications() override;
+  void FallThrough(int call_id,
+                   crdtp::span<uint8_t> method,
                    crdtp::span<uint8_t> message) override;
 
   std::string name_;

components/ui_devtools/dom_agent.cc

@@ -105,21 +105,21 @@ DOMAgent::~DOMAgent() {
 
 Response DOMAgent::disable() {
   Reset();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response DOMAgent::getDocument(std::unique_ptr<Node>* out_root) {
   element_root_->ResetNodeId();
   *out_root = BuildInitialTree();
   is_document_created_ = true;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response DOMAgent::pushNodesByBackendIdsToFrontend(
     std::unique_ptr<protocol::Array<int>> backend_node_ids,
     std::unique_ptr<protocol::Array<int>>* result) {
   *result = std::move(backend_node_ids);
-  return Response::OK();
+  return Response::Success();
 }
 
 void DOMAgent::OnUIElementAdded(UIElement* parent, UIElement* child) {
@@ -351,7 +351,7 @@ Response DOMAgent::performSearch(
     int* result_count) {
   Query query_data = PreprocessQuery(whitespace_trimmed_query);
   if (!query_data.query_.length())
-    return Response::OK();
+    return Response::Success();
 
   std::vector<int> result_collector;
   SearchDomTree(query_data, &result_collector);
@@ -360,7 +360,7 @@ Response DOMAgent::performSearch(
   *result_count = result_collector.size();
   search_results_.insert(
       std::make_pair(*search_id, std::move(result_collector)));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response DOMAgent::getSearchResults(
@@ -370,21 +370,21 @@ Response DOMAgent::getSearchResults(
     std::unique_ptr<protocol::Array<int>>* node_ids) {
   SearchResults::iterator it = search_results_.find(search_id);
   if (it == search_results_.end())
-    return Response::Error("No search session with given id found");
+    return Response::ServerError("No search session with given id found");
 
   int size = it->second.size();
   if (from_index < 0 || to_index > size || from_index >= to_index)
-    return Response::Error("Invalid search result range");
+    return Response::ServerError("Invalid search result range");
 
   *node_ids = std::make_unique<protocol::Array<int>>();
   for (int i = from_index; i < to_index; ++i)
     (*node_ids)->emplace_back((it->second)[i]);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response DOMAgent::discardSearchResults(const protocol::String& search_id) {
   search_results_.erase(search_id);
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace ui_devtools

components/ui_devtools/overlay_agent.cc

@@ -16,18 +16,18 @@ protocol::Response OverlayAgent::setInspectMode(
     const protocol::String& in_mode,
     protocol::Maybe<protocol::Overlay::HighlightConfig> in_highlightConfig) {
   NOTREACHED();
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response OverlayAgent::highlightNode(
     std::unique_ptr<protocol::Overlay::HighlightConfig> highlight_config,
     protocol::Maybe<int> node_id) {
   NOTREACHED();
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response OverlayAgent::hideHighlight() {
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 }  // namespace ui_devtools

components/ui_devtools/page_agent.cc

@@ -12,7 +12,7 @@ PageAgent::~PageAgent() {}
 
 protocol::Response PageAgent::reload(protocol::Maybe<bool> bypass_cache) {
   NOTREACHED();
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 }  // namespace ui_devtools

components/ui_devtools/tracing_agent.cc

@@ -351,7 +351,7 @@ void TracingAgent::start(
     protocol::Maybe<double> buffer_usage_reporting_interval,
     std::unique_ptr<StartCallback> callback) {
   if (g_any_agent_tracing) {
-    callback->sendFailure(Response::Error("Tracing is already started"));
+    callback->sendFailure(Response::ServerError("Tracing is already started"));
     return;
   }
 
@@ -378,10 +378,10 @@ void TracingAgent::start(
 
 Response TracingAgent::end() {
   if (!perfetto_session_)
-    return Response::Error("Tracing is not started");
+    return Response::ServerError("Tracing is not started");
 
   if (perfetto_session_->HasTracingFailed())
-    return Response::Error("Tracing failed");
+    return Response::ServerError("Tracing failed");
 
   scoped_refptr<DevToolsTraceEndpointProxy> endpoint;
   // Reset the trace data buffer state.
@@ -389,7 +389,7 @@ Response TracingAgent::end() {
   endpoint = new DevToolsTraceEndpointProxy(weak_factory_.GetWeakPtr());
   StopTracing(endpoint, tracing::mojom::kChromeTraceEventLabel);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void TracingAgent::StartTracing(std::unique_ptr<StartCallback> callback) {

components/ui_devtools/ui_devtools_unittest_utils.cc

@@ -30,21 +30,14 @@ int FakeFrontendChannel::CountProtocolNotificationMessage(
                     protocol_notification_messages_.end(), message);
 }
 
-namespace {
-std::string SerializeToJSON(std::unique_ptr<protocol::Serializable> message) {
+void FakeFrontendChannel::SendProtocolNotification(
+    std::unique_ptr<protocol::Serializable> message) {
+  EXPECT_TRUE(allow_notifications_);
   std::string json;
   crdtp::Status status = crdtp::json::ConvertCBORToJSON(
       crdtp::SpanFrom(message->Serialize()), &json);
   DCHECK(status.ok()) << status.ToASCIIString();
-  return json;
-}
-}  // namespace
-
-void FakeFrontendChannel::sendProtocolNotification(
-    std::unique_ptr<protocol::Serializable> message) {
-  EXPECT_TRUE(allow_notifications_);
-  protocol_notification_messages_.push_back(
-      SerializeToJSON(std::move(message)));
+  protocol_notification_messages_.push_back(std::move(json));
 }
 
 }  // namespace ui_devtools

components/ui_devtools/ui_devtools_unittest_utils.h

@@ -25,14 +25,14 @@ class FakeFrontendChannel : public protocol::FrontendChannel {
   }
 
   // FrontendChannel:
-  void sendProtocolResponse(
+  void SendProtocolResponse(
       int callId,
       std::unique_ptr<protocol::Serializable> message) override {}
-  void flushProtocolNotifications() override {}
-  void fallThrough(int call_id,
-                   const std::string& method,
+  void FlushProtocolNotifications() override {}
+  void FallThrough(int call_id,
+                   crdtp::span<uint8_t> method,
                    crdtp::span<uint8_t> message) override {}
-  void sendProtocolNotification(
+  void SendProtocolNotification(
       std::unique_ptr<protocol::Serializable> message) override;
 
  private:

components/ui_devtools/views/overlay_agent_views.cc

@@ -391,7 +391,7 @@ protocol::Response OverlayAgentViews::setInspectMode(
   } else if (in_mode.compare("none") == 0) {
     RemovePreTargetHandler();
   }
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response OverlayAgentViews::highlightNode(
@@ -403,7 +403,7 @@ protocol::Response OverlayAgentViews::highlightNode(
 protocol::Response OverlayAgentViews::hideHighlight() {
   if (layer_for_highlighting_ && layer_for_highlighting_->visible())
     layer_for_highlighting_->SetVisible(false);
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 void OverlayAgentViews::ShowDistancesInHighlightOverlay(int pinned_id,
@@ -469,10 +469,10 @@ protocol::Response OverlayAgentViews::HighlightNode(int node_id,
                                                     bool show_size) {
   UIElement* element = dom_agent()->GetElementFromNodeId(node_id);
   if (!element)
-    return protocol::Response::Error("No node found with that id");
+    return protocol::Response::ServerError("No node found with that id");
 
   if (element->type() == UIElementType::ROOT)
-    return protocol::Response::Error("Cannot highlight root node.");
+    return protocol::Response::ServerError("Cannot highlight root node.");
 
   if (!layer_for_highlighting_) {
     layer_for_highlighting_.reset(new ui::Layer(ui::LayerType::LAYER_TEXTURED));
@@ -485,7 +485,7 @@ protocol::Response OverlayAgentViews::HighlightNode(int node_id,
   show_size_on_canvas_ = show_size;
   layer_for_highlighting_->SetVisible(
       UpdateHighlight(element->GetNodeWindowAndScreenBounds()));
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 void OverlayAgentViews::OnMouseEvent(ui::MouseEvent* event) {

components/ui_devtools/views/page_agent_views.cc

@@ -73,12 +73,12 @@ protocol::Response PageAgentViews::disable() {
         base::CommandLine::ForCurrentProcess()->argv());
     PaintRectVector(dom_agent_->element_root()->children());
   }
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response PageAgentViews::reload(protocol::Maybe<bool> bypass_cache) {
   if (!bypass_cache.isJust())
-    return protocol::Response::OK();
+    return protocol::Response::Success();
 
   bool shift_pressed = bypass_cache.fromMaybe(false);
 
@@ -98,7 +98,7 @@ protocol::Response PageAgentViews::reload(protocol::Maybe<bool> bypass_cache) {
     }
     PaintRectVector(dom_agent_->element_root()->children());
   }
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response PageAgentViews::getResourceTree(
@@ -128,7 +128,7 @@ protocol::Response PageAgentViews::getResourceTree(
           .setResources(std::move(subresources))
           .build();
   *object = std::move(result);
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response PageAgentViews::getResourceContent(
@@ -139,17 +139,17 @@ protocol::Response PageAgentViews::getResourceContent(
   auto split_url = base::SplitStringUsingSubstr(
       in_url, "src/", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (split_url.size() != 2)
-    return protocol::Response::Error("Invalid URL");
+    return protocol::Response::ServerError("Invalid URL");
 
   auto split_path = base::SplitStringUsingSubstr(
       split_url[1], "?l=", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (split_path.size() != 2)
-    return protocol::Response::Error("Invalid URL");
+    return protocol::Response::ServerError("Invalid URL");
 
   if (GetSourceCode(split_path[0], out_content))
-    return protocol::Response::OK();
+    return protocol::Response::Success();
   else
-    return protocol::Response::Error("Could not read source file");
+    return protocol::Response::ServerError("Could not read source file");
 }
 
 bool PageAgentViews::devtools_dismiss_override() {

components/ui_devtools/views/page_agent_views_unittest.cc

@@ -74,7 +74,7 @@ class PageAgentViewsTest : public views::ViewsTestBase {
 
     auto response =
         page_agent()->getResourceContent("1", url_input, &result, &out_bool);
-    return {response.isSuccess(), result};
+    return {response.IsSuccess(), result};
   }
 
  protected:
@@ -151,7 +151,7 @@ TEST_F(PageAgentViewsTest, ResetOnDisable) {
 
 TEST_F(PageAgentViewsTest, GetResourceTree) {
   std::unique_ptr<protocol::Page::FrameResourceTree> resource_tree;
-  EXPECT_TRUE(page_agent()->getResourceTree(&resource_tree).isSuccess());
+  EXPECT_TRUE(page_agent()->getResourceTree(&resource_tree).IsSuccess());
 
   protocol::Page::Frame* frame_object = resource_tree->getFrame();
   EXPECT_EQ(frame_object->getId(), "1");
@@ -190,4 +190,4 @@ TEST_F(PageAgentViewsTest, GetResourceContentFailsOnBadURL) {
   EXPECT_EQ(result.second, "");
 }
 
-}  // namespace ui_devtools
+}  // namespace ui_devtools

components/ui_devtools/viz/BUILD.gn

@@ -21,6 +21,7 @@ source_set("viz") {
   deps = [
     "//components/ui_devtools",
     "//components/viz/service",
+    "//third_party/inspector_protocol:crdtp",
   ]
 }
 

components/ui_devtools/viz/dom_agent_viz.cc

@@ -298,7 +298,7 @@ std::unique_ptr<protocol::DOM::Node> DOMAgentViz::BuildTreeForSurface(
 protocol::Response DOMAgentViz::enable() {
   frame_sink_manager_->AddObserver(this);
   surface_manager_->AddObserver(this);
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response DOMAgentViz::disable() {

components/ui_devtools/viz/overlay_agent_viz.cc

@@ -14,17 +14,17 @@ OverlayAgentViz::~OverlayAgentViz() {}
 protocol::Response OverlayAgentViz::setInspectMode(
     const protocol::String& in_mode,
     protocol::Maybe<protocol::Overlay::HighlightConfig> in_highlightConfig) {
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response OverlayAgentViz::highlightNode(
     std::unique_ptr<protocol::Overlay::HighlightConfig> highlight_config,
     protocol::Maybe<int> node_id) {
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response OverlayAgentViz::hideHighlight() {
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 }  // namespace ui_devtools

content/browser/devtools/devtools_agent_host_impl.cc

@@ -163,13 +163,12 @@ bool DevToolsAgentHostImpl::DetachClient(DevToolsAgentHostClient* client) {
   return true;
 }
 
-bool DevToolsAgentHostImpl::DispatchProtocolMessage(
+void DevToolsAgentHostImpl::DispatchProtocolMessage(
     DevToolsAgentHostClient* client,
     base::span<const uint8_t> message) {
   DevToolsSession* session = SessionByClient(client);
-  if (!session)
-    return false;
-  return session->DispatchProtocolMessage(message);
+  if (session)
+    session->DispatchProtocolMessage(message);
 }
 
 void DevToolsAgentHostImpl::DetachInternal(DevToolsSession* session) {

content/browser/devtools/devtools_agent_host_impl.h

@@ -31,7 +31,7 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost {
   // DevToolsAgentHost implementation.
   bool AttachClient(DevToolsAgentHostClient* client) override;
   bool DetachClient(DevToolsAgentHostClient* client) override;
-  bool DispatchProtocolMessage(DevToolsAgentHostClient* client,
+  void DispatchProtocolMessage(DevToolsAgentHostClient* client,
                                base::span<const uint8_t> message) override;
   bool IsAttached() override;
   void InspectElement(RenderFrameHost* frame_host, int x, int y) override;

content/browser/devtools/devtools_session.cc

@@ -8,6 +8,8 @@
 #include <vector>
 
 #include "base/bind.h"
+#include "base/containers/flat_set.h"
+#include "base/debug/stack_trace.h"
 #include "content/browser/devtools/devtools_manager.h"
 #include "content/browser/devtools/protocol/devtools_domain_handler.h"
 #include "content/browser/devtools/protocol/protocol.h"
@@ -16,22 +18,29 @@
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 #include "third_party/inspector_protocol/crdtp/cbor.h"
+#include "third_party/inspector_protocol/crdtp/dispatch.h"
 #include "third_party/inspector_protocol/crdtp/json.h"
 
 namespace content {
 namespace {
-
-bool ShouldSendOnIO(const std::string& method) {
-  // Keep in sync with WebDevToolsAgent::ShouldInterruptForMethod.
-  // TODO(petermarshall): find a way to share this.
-  return method == "Debugger.pause" || method == "Debugger.setBreakpoint" ||
-         method == "Debugger.setBreakpointByUrl" ||
-         method == "Debugger.removeBreakpoint" ||
-         method == "Debugger.setBreakpointsActive" ||
-         method == "Debugger.getStackTrace" ||
-         method == "Performance.getMetrics" || method == "Page.crash" ||
-         method == "Runtime.terminateExecution" ||
-         method == "Emulation.setScriptExecutionDisabled";
+// Keep in sync with WebDevToolsAgent::ShouldInterruptForMethod.
+// TODO(petermarshall): find a way to share this.
+bool ShouldSendOnIO(crdtp::span<uint8_t> method) {
+  static auto* kEntries = new std::vector<crdtp::span<uint8_t>>{
+      crdtp::SpanFrom("Debugger.getStackTrace"),
+      crdtp::SpanFrom("Debugger.pause"),
+      crdtp::SpanFrom("Debugger.removeBreakpoint"),
+      crdtp::SpanFrom("Debugger.setBreakpoint"),
+      crdtp::SpanFrom("Debugger.setBreakpointByUrl"),
+      crdtp::SpanFrom("Debugger.setBreakpointsActive"),
+      crdtp::SpanFrom("Emulation.setScriptExecutionDisabled"),
+      crdtp::SpanFrom("Page.crash"),
+      crdtp::SpanFrom("Performance.getMetrics"),
+      crdtp::SpanFrom("Runtime.terminateExecution"),
+  };
+  DCHECK(std::is_sorted(kEntries->begin(), kEntries->end(), crdtp::SpanLt()));
+  return std::binary_search(kEntries->begin(), kEntries->end(), method,
+                            crdtp::SpanLt());
 }
 
 // Async control commands (such as CSS.enable) are idempotant and can
@@ -43,13 +52,19 @@ bool ShouldSendOnIO(const std::string& method) {
 // Ideally all non-control async commands shoulds be listed here but we
 // conservatively start with Runtime domain where the decision is more
 // clear.
-bool TerminateOnCrossProcessNavigation(const std::string& method) {
-  return method == "Runtime.evaluate" || method == "Runtime.awaitPromise" ||
-         method == "Runtime.callFunctionOn" || method == "Runtime.runScript" ||
-         method == "Runtime.terminateExecution";
+bool TerminateOnCrossProcessNavigation(crdtp::span<uint8_t> method) {
+  static auto* kEntries = new std::vector<crdtp::span<uint8_t>>{
+      crdtp::SpanFrom("Runtime.awaitPromise"),
+      crdtp::SpanFrom("Runtime.callFunctionOn"),
+      crdtp::SpanFrom("Runtime.evaluate"),
+      crdtp::SpanFrom("Runtime.runScript"),
+      crdtp::SpanFrom("Runtime.terminateExecution"),
+  };
+  DCHECK(std::is_sorted(kEntries->begin(), kEntries->end(), crdtp::SpanLt()));
+  return std::binary_search(kEntries->begin(), kEntries->end(), method,
+                            crdtp::SpanLt());
 }
 
-const char kMethod[] = "method";
 const char kResumeMethod[] = "Runtime.runIfWaitingForDebugger";
 const char kSessionId[] = "sessionId";
 
@@ -59,10 +74,10 @@ const char kTargetClosedMessage[] = "Inspected target navigated or closed";
 
 DevToolsSession::PendingMessage::PendingMessage(PendingMessage&&) = default;
 DevToolsSession::PendingMessage::PendingMessage(int call_id,
-                                                const std::string& method,
+                                                crdtp::span<uint8_t> method,
                                                 crdtp::span<uint8_t> payload)
     : call_id(call_id),
-      method(method),
+      method(method.begin(), method.end()),
       payload(payload.begin(), payload.end()) {}
 
 DevToolsSession::PendingMessage::~PendingMessage() = default;
@@ -162,12 +177,13 @@ void DevToolsSession::AttachToAgent(blink::mojom::DevToolsAgent* agent,
     for (auto it = pending_messages_.begin(); it != pending_messages_.end();) {
       const PendingMessage& message = *it;
       if (waiting_for_response_.count(message.call_id) &&
-          TerminateOnCrossProcessNavigation(message.method)) {
+          TerminateOnCrossProcessNavigation(crdtp::SpanFrom(message.method))) {
         // Send error to the client and remove the message from pending.
-        auto error = protocol::InternalResponse::createErrorResponse(
-            message.call_id, protocol::DispatchResponse::kServerError,
-            kTargetClosedMessage);
-        sendProtocolResponse(message.call_id, std::move(error));
+        SendProtocolResponse(
+            message.call_id,
+            crdtp::CreateErrorResponse(
+                message.call_id,
+                crdtp::DispatchResponse::ServerError(kTargetClosedMessage)));
         it = pending_messages_.erase(it);
       } else {
         // We'll send or re-send the message in ResumeSendingMessagesToAgent.
@@ -197,93 +213,124 @@ void DevToolsSession::MojoConnectionDestroyed() {
 
 // The client of the devtools session will call this method to send a message
 // to handlers / agents that the session is connected with.
-bool DevToolsSession::DispatchProtocolMessage(
+void DevToolsSession::DispatchProtocolMessage(
     base::span<const uint8_t> message) {
+  if (client_->UsesBinaryProtocol()) {
+    crdtp::Status status =
+        crdtp::cbor::CheckCBORMessage(crdtp::SpanFrom(message));
+    if (!status.ok()) {
+      DispatchProtocolMessageToClient(
+          crdtp::CreateErrorNotification(
+              crdtp::DispatchResponse::ParseError(status.ToASCIIString()))
+              ->Serialize());
+      return;
+    }
+  }
+
   // If the session is in proxy mode, then |message| will be sent to
   // an external session, so it needs to be sent as JSON.
   // TODO(dgozman): revisit the proxy delegate.
-  if (proxy_delegate_) {
-    if (client_->UsesBinaryProtocol()) {
-      DCHECK(crdtp::cbor::IsCBORMessage(crdtp::SpanFrom(message)));
-      std::vector<uint8_t> json;
-      crdtp::Status status =
-          crdtp::json::ConvertCBORToJSON(crdtp::SpanFrom(message), &json);
-      LOG_IF(ERROR, !status.ok()) << status.ToASCIIString();
-      proxy_delegate_->SendMessageToBackend(this, json);
-      return true;
+  if (proxy_delegate_) {                   // External session wants JSON.
+    if (!client_->UsesBinaryProtocol()) {  // Client sent JSON.
+      proxy_delegate_->SendMessageToBackend(this, message);
+      return;
     }
-    proxy_delegate_->SendMessageToBackend(this, message);
-    return true;
+    // External session wants JSON, but client provided CBOR.
+    std::vector<uint8_t> json;
+    crdtp::Status status =
+        crdtp::json::ConvertCBORToJSON(crdtp::SpanFrom(message), &json);
+    if (status.ok()) {
+      proxy_delegate_->SendMessageToBackend(this, json);
+      return;
+    }
+    DispatchProtocolMessageToClient(
+        crdtp::CreateErrorNotification(
+            crdtp::DispatchResponse::ParseError(status.ToASCIIString()))
+            ->Serialize());
+    return;
   }
+  // Before dispatching, convert the message to CBOR if needed.
   std::vector<uint8_t> converted_cbor_message;
-  if (client_->UsesBinaryProtocol()) {
-    // If the client uses the binary protocol, then |message| is already
-    // CBOR (it comes from the client).
-    DCHECK(crdtp::cbor::IsCBORMessage(crdtp::SpanFrom(message)));
-  } else {
+  if (!client_->UsesBinaryProtocol()) {  // Client sent JSON.
     crdtp::Status status = crdtp::json::ConvertJSONToCBOR(
         crdtp::SpanFrom(message), &converted_cbor_message);
-    LOG_IF(ERROR, !status.ok()) << status.ToASCIIString();
+    if (!status.ok()) {
+      DispatchProtocolMessageToClient(
+          crdtp::CreateErrorNotification(
+              crdtp::DispatchResponse::ParseError(status.ToASCIIString()))
+              ->Serialize());
+      return;
+    }
     message = converted_cbor_message;
   }
-  std::unique_ptr<protocol::DictionaryValue> value =
-      protocol::DictionaryValue::cast(
-          protocol::Value::parseBinary(message.data(), message.size()));
-
-  std::string session_id;
-  if (!value || !value->getString(kSessionId, &session_id))
-    return DispatchProtocolMessageInternal(message, std::move(value));
+  // At this point |message| is CBOR.
+  crdtp::Dispatchable dispatchable(crdtp::SpanFrom(message));
+  if (!dispatchable.ok()) {
+    DispatchProtocolMessageToClient(
+        (dispatchable.HasCallId()
+             ? crdtp::CreateErrorResponse(dispatchable.CallId(),
+                                          dispatchable.DispatchError())
+             : crdtp::CreateErrorNotification(dispatchable.DispatchError()))
+            ->Serialize());
 
+    return;
+  }
+  if (dispatchable.SessionId().empty()) {
+    DispatchProtocolMessageInternal(std::move(dispatchable), message);
+    return;
+  }
+  std::string session_id(dispatchable.SessionId().begin(),
+                         dispatchable.SessionId().end());
   auto it = child_sessions_.find(session_id);
   if (it == child_sessions_.end())
-    return false;
+    return;
   DevToolsSession* session = it->second;
   DCHECK(!session->proxy_delegate_);
-  return session->DispatchProtocolMessageInternal(message, std::move(value));
+  session->DispatchProtocolMessageInternal(std::move(dispatchable), message);
 }
 
-bool DevToolsSession::DispatchProtocolMessageInternal(
-    base::span<const uint8_t> message,
-    std::unique_ptr<protocol::DictionaryValue> value) {
-  std::string method;
-  bool has_method = value && value->getString(kMethod, &method);
-  if (!runtime_resume_.is_null() && has_method && method == kResumeMethod)
+void DevToolsSession::DispatchProtocolMessageInternal(
+    crdtp::Dispatchable dispatchable,
+    base::span<const uint8_t> message) {
+  if (!runtime_resume_.is_null() &&
+      crdtp::SpanEquals(crdtp::SpanFrom(kResumeMethod), dispatchable.Method()))
     std::move(runtime_resume_).Run();
 
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
-  if (delegate && has_method) {
-    delegate->HandleCommand(
-        this, method, message,
-        base::BindOnce(&DevToolsSession::HandleCommand,
-                       weak_factory_.GetWeakPtr(), std::move(value)));
+  if (delegate && !dispatchable.Method().empty()) {
+    delegate->HandleCommand(this, message,
+                            base::BindOnce(&DevToolsSession::HandleCommand,
+                                           weak_factory_.GetWeakPtr()));
   } else {
-    HandleCommand(std::move(value), message);
-  }
-  return true;
-}
-
-void DevToolsSession::HandleCommand(
-    std::unique_ptr<protocol::DictionaryValue> value,
-    base::span<const uint8_t> message) {
-  int call_id;
-  std::string method;
-  if (!dispatcher_->parseCommand(value.get(), &call_id, &method))
-    return;
-  if (browser_only_ || dispatcher_->canDispatch(method)) {
-    TRACE_EVENT_WITH_FLOW2("devtools",
-                           "DevToolsSession::HandleCommand in Browser", call_id,
-                           TRACE_EVENT_FLAG_FLOW_OUT, "method", method.c_str(),
-                           "call_id", call_id);
-    dispatcher_->dispatch(call_id, method, std::move(value),
-                          crdtp::SpanFrom(message));
-  } else {
-    fallThrough(call_id, method, crdtp::SpanFrom(message));
+    HandleCommandInternal(std::move(dispatchable), message);
   }
 }
 
-void DevToolsSession::fallThrough(int call_id,
-                                  const std::string& method,
+void DevToolsSession::HandleCommand(base::span<const uint8_t> message) {
+  HandleCommandInternal(crdtp::Dispatchable(crdtp::SpanFrom(message)), message);
+}
+
+void DevToolsSession::HandleCommandInternal(crdtp::Dispatchable dispatchable,
+                                            base::span<const uint8_t> message) {
+  DCHECK(dispatchable.ok());
+  crdtp::UberDispatcher::DispatchResult dispatched =
+      dispatcher_->Dispatch(dispatchable);
+  if (browser_only_ || dispatched.MethodFound()) {
+    TRACE_EVENT_WITH_FLOW2(
+        "devtools", "DevToolsSession::HandleCommand in Browser",
+        dispatchable.CallId(), TRACE_EVENT_FLAG_FLOW_OUT, "method",
+        std::string(dispatchable.Method().begin(), dispatchable.Method().end()),
+        "call_id", dispatchable.CallId());
+    dispatched.Run();
+  } else {
+    FallThrough(dispatchable.CallId(), dispatchable.Method(),
+                crdtp::SpanFrom(message));
+  }
+}
+
+void DevToolsSession::FallThrough(int call_id,
+                                  crdtp::span<uint8_t> method,
                                   crdtp::span<uint8_t> message) {
   // In browser-only mode, we should've handled everything in dispatcher.
   DCHECK(!browser_only_);
@@ -312,7 +359,7 @@ void DevToolsSession::DispatchProtocolMessageToClient(
     std::vector<uint8_t> json;
     crdtp::Status status =
         crdtp::json::ConvertCBORToJSON(crdtp::SpanFrom(message), &json);
-    LOG_IF(ERROR, !status.ok()) << status.ToASCIIString();
+    DCHECK(status.ok()) << status.ToASCIIString();
     message = std::move(json);
   }
   client_->DispatchProtocolMessage(agent_host_, message);
@@ -330,7 +377,7 @@ void DevToolsSession::DispatchToAgent(const PendingMessage& message) {
   DCHECK(!browser_only_);
   // We send all messages on the IO channel for workers so that messages like
   // Debugger.pause don't get stuck behind other blocking messages.
-  if (ShouldSendOnIO(message.method) || use_io_session_) {
+  if (ShouldSendOnIO(crdtp::SpanFrom(message.method)) || use_io_session_) {
     if (io_session_) {
       TRACE_EVENT_WITH_FLOW2(
           "devtools", "DevToolsSession::DispatchToAgent on IO", message.call_id,
@@ -371,21 +418,20 @@ void DevToolsSession::ResumeSendingMessagesToAgent() {
 
 // The following methods handle responses or notifications coming from
 // the browser to the client.
-void DevToolsSession::sendProtocolResponse(
+void DevToolsSession::SendProtocolResponse(
     int call_id,
     std::unique_ptr<protocol::Serializable> message) {
   DispatchProtocolMessageToClient(message->Serialize());
   // |this| may be deleted at this point.
 }
 
-void DevToolsSession::sendProtocolNotification(
+void DevToolsSession::SendProtocolNotification(
     std::unique_ptr<protocol::Serializable> message) {
   DispatchProtocolMessageToClient(message->Serialize());
   // |this| may be deleted at this point.
 }
 
-void DevToolsSession::flushProtocolNotifications() {
-}
+void DevToolsSession::FlushProtocolNotifications() {}
 
 // The following methods handle responses or notifications coming from the
 // renderer (blink) to the client. It is important that these messages not be
@@ -452,7 +498,7 @@ void DevToolsSession::ConnectionClosed() {
   DevToolsAgentHostClient* client = client_;
   DevToolsAgentHostImpl* agent_host = agent_host_;
   agent_host->DetachInternal(this);
-  // |this| is delete here, do not use any fields below.
+  // |this| is deleted here, do not use any fields below.
   client->AgentHostClosed(agent_host);
 }
 

content/browser/devtools/devtools_session.h

@@ -61,7 +61,7 @@ class DevToolsSession : public protocol::FrontendChannel,
 
   void AttachToAgent(blink::mojom::DevToolsAgent* agent,
                      bool force_using_io_session);
-  bool DispatchProtocolMessage(base::span<const uint8_t> message);
+  void DispatchProtocolMessage(base::span<const uint8_t> message);
   void SuspendSendingMessagesToAgent();
   void ResumeSendingMessagesToAgent();
 
@@ -88,28 +88,28 @@ class DevToolsSession : public protocol::FrontendChannel,
 
     PendingMessage(PendingMessage&&);
     PendingMessage(int call_id,
-                   const std::string& method,
+                   crdtp::span<uint8_t> method,
                    crdtp::span<uint8_t> payload);
     ~PendingMessage();
   };
 
   void MojoConnectionDestroyed();
   void DispatchToAgent(const PendingMessage& message);
-  void HandleCommand(std::unique_ptr<protocol::DictionaryValue> value,
-                     base::span<const uint8_t> message);
-  bool DispatchProtocolMessageInternal(
-      base::span<const uint8_t> message,
-      std::unique_ptr<protocol::DictionaryValue> value);
+  void HandleCommand(base::span<const uint8_t> message);
+  void HandleCommandInternal(crdtp::Dispatchable dispatchable,
+                             base::span<const uint8_t> message);
+  void DispatchProtocolMessageInternal(crdtp::Dispatchable dispatchable,
+                                       base::span<const uint8_t> message);
 
   // protocol::FrontendChannel implementation.
-  void sendProtocolResponse(
+  void SendProtocolResponse(
       int call_id,
       std::unique_ptr<protocol::Serializable> message) override;
-  void sendProtocolNotification(
+  void SendProtocolNotification(
       std::unique_ptr<protocol::Serializable> message) override;
-  void flushProtocolNotifications() override;
-  void fallThrough(int call_id,
-                   const std::string& method,
+  void FlushProtocolNotifications() override;
+  void FallThrough(int call_id,
+                   crdtp::span<uint8_t> method,
                    crdtp::span<uint8_t> message) override;
 
   // content::DevToolsAgentHostClientChannel implementation.

content/browser/devtools/devtools_url_loader_interceptor.cc

@@ -193,7 +193,7 @@ class BodyReader : public mojo::DataPipeDrainer::Client {
 
   void CancelWithError(std::string error) {
     for (auto& cb : callbacks_)
-      cb->sendFailure(Response::Error(error));
+      cb->sendFailure(Response::ServerError(error));
     callbacks_.clear();
   }
 
@@ -793,7 +793,7 @@ void InterceptionJob::GetResponseBody(
     std::unique_ptr<GetResponseBodyCallback> callback) {
   std::string error_reason;
   if (!CanGetResponseBody(&error_reason)) {
-    callback->sendFailure(Response::Error(std::move(error_reason)));
+    callback->sendFailure(Response::ServerError(std::move(error_reason)));
     return;
   }
   if (!body_reader_) {
@@ -809,7 +809,7 @@ void InterceptionJob::TakeResponseBodyPipe(
     TakeResponseBodyPipeCallback callback) {
   std::string error_reason;
   if (!CanGetResponseBody(&error_reason)) {
-    std::move(callback).Run(Response::Error(std::move(error_reason)),
+    std::move(callback).Run(Response::ServerError(std::move(error_reason)),
                             mojo::ScopedDataPipeConsumerHandle(),
                             base::EmptyString());
     return;
@@ -827,7 +827,7 @@ void InterceptionJob::ContinueInterceptedRequest(
     std::unique_ptr<ContinueInterceptedRequestCallback> callback) {
   Response response = InnerContinueRequest(std::move(modifications));
   // |this| may be destroyed at this point.
-  if (response.isSuccess())
+  if (response.IsSuccess())
     callback->sendSuccess();
   else
     callback->sendFailure(std::move(response));
@@ -850,14 +850,15 @@ void InterceptionJob::Detach() {
 Response InterceptionJob::InnerContinueRequest(
     std::unique_ptr<Modifications> modifications) {
   if (!waiting_for_resolution_)
-    return Response::Error("Invalid state for continueInterceptedRequest");
+    return Response::ServerError(
+        "Invalid state for continueInterceptedRequest");
   waiting_for_resolution_ = false;
 
   if (state_ == State::kAuthRequired) {
     if (!modifications->auth_challenge_response)
       return Response::InvalidParams("authChallengeResponse required.");
     ProcessAuthResponse(*modifications->auth_challenge_response);
-    return Response::OK();
+    return Response::Success();
   }
   if (modifications->auth_challenge_response)
     return Response::InvalidParams("authChallengeResponse not expected.");
@@ -876,7 +877,7 @@ Response InterceptionJob::InnerContinueRequest(
     }
     client_->OnComplete(status);
     Shutdown();
-    return Response::OK();
+    return Response::Success();
   }
 
   if (modifications->response_headers || modifications->response_body)
@@ -893,7 +894,7 @@ Response InterceptionJob::InnerContinueRequest(
       // TODO(caseq): report error if other modifications are present.
       state_ = State::kRequestSent;
       loader_->FollowRedirect({}, {}, base::nullopt);
-      return Response::OK();
+      return Response::Success();
     }
   }
   if (state_ == State::kRedirectReceived) {
@@ -906,13 +907,13 @@ Response InterceptionJob::InnerContinueRequest(
       headers->AddHeader("location: " + location);
       GURL redirect_url = create_loader_params_->request.url.Resolve(location);
       if (!redirect_url.is_valid())
-        return Response::Error("Invalid modified URL");
+        return Response::ServerError("Invalid modified URL");
       ProcessRedirectByClient(redirect_url);
-      return Response::OK();
+      return Response::Success();
     }
     client_->OnReceiveRedirect(*response_metadata_->redirect_info,
                                std::move(response_metadata_->head));
-    return Response::OK();
+    return Response::Success();
   }
 
   if (body_reader_) {
@@ -921,7 +922,7 @@ Response InterceptionJob::InnerContinueRequest(
 
     // There are read callbacks pending, so let the reader do its job and come
     // back when it's done.
-    return Response::OK();
+    return Response::Success();
   }
 
   if (response_metadata_) {
@@ -936,13 +937,13 @@ Response InterceptionJob::InnerContinueRequest(
     response_metadata_.reset();
     loader_->ResumeReadingBodyFromNet();
     client_receiver_.Resume();
-    return Response::OK();
+    return Response::Success();
   }
 
   DCHECK_EQ(State::kNotStarted, state_);
   ApplyModificationsToRequest(std::move(modifications));
   StartRequest();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InterceptionJob::ApplyModificationsToRequest(
@@ -1066,7 +1067,7 @@ Response InterceptionJob::ProcessResponseOverride(
   }
   ProcessSetCookies(*head->headers, std::move(continue_after_cookies_set));
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void InterceptionJob::ProcessSetCookies(const net::HttpResponseHeaders& headers,
@@ -1438,7 +1439,7 @@ void InterceptionJob::OnStartLoadingResponseBody(
     DCHECK_EQ(State::kResponseTaken, state_);
     DCHECK(!body_reader_);
     std::move(pending_response_body_pipe_callback_)
-        .Run(Response::OK(), std::move(body),
+        .Run(Response::Success(), std::move(body),
              response_metadata_->head->mime_type);
     return;
   }

content/browser/devtools/protocol/background_service_handler.cc

@@ -136,7 +136,7 @@ Response BackgroundServiceHandler::Disable() {
   if (!enabled_services_.empty())
     devtools_context_->RemoveObserver(this);
   enabled_services_.clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 void BackgroundServiceHandler::StartObserving(
@@ -177,13 +177,13 @@ Response BackgroundServiceHandler::StopObserving(const std::string& service) {
     return Response::InvalidParams("Invalid service name");
 
   if (!enabled_services_.count(service_enum))
-    return Response::OK();
+    return Response::Success();
 
   enabled_services_.erase(service_enum);
   if (enabled_services_.empty())
     devtools_context_->RemoveObserver(this);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void BackgroundServiceHandler::DidGetLoggedEvents(
@@ -216,7 +216,7 @@ Response BackgroundServiceHandler::SetRecording(bool should_record,
     devtools_context_->StopRecording(service_enum);
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BackgroundServiceHandler::ClearEvents(const std::string& service) {
@@ -227,7 +227,7 @@ Response BackgroundServiceHandler::ClearEvents(const std::string& service) {
     return Response::InvalidParams("Invalid service name");
 
   devtools_context_->ClearLoggedBackgroundServiceEvents(service_enum);
-  return Response::OK();
+  return Response::Success();
 }
 
 void BackgroundServiceHandler::OnEventReceived(

content/browser/devtools/protocol/browser_handler.cc

@@ -50,7 +50,7 @@ Response BrowserHandler::Disable() {
     }
   }
   contexts_with_overridden_permissions_.clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 void BrowserHandler::Wire(UberDispatcher* dispatcher) {
@@ -67,7 +67,7 @@ Response BrowserHandler::GetVersion(std::string* protocol_version,
   *product = GetContentClient()->browser()->GetProduct();
   *user_agent = GetContentClient()->browser()->GetUserAgent();
   *js_version = V8_VERSION_STRING;
-  return Response::OK();
+  return Response::Success();
 }
 
 namespace {
@@ -183,7 +183,7 @@ Response PermissionDescriptorToPermissionType(
                                    name);
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response FromProtocolPermissionType(
@@ -239,7 +239,7 @@ Response FromProtocolPermissionType(
   } else {
     return Response::InvalidParams("Unknown permission type: " + type);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response PermissionSettingToPermissionStatus(
@@ -254,7 +254,7 @@ Response PermissionSettingToPermissionStatus(
   } else {
     return Response::InvalidParams("Unknown permission setting: " + setting);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace
@@ -274,7 +274,7 @@ Response BrowserHandler::GetHistograms(
     (*out_histograms)->emplace_back(Convert(*h, in_delta.fromMaybe(false)));
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 // static
@@ -284,19 +284,21 @@ Response BrowserHandler::FindBrowserContext(
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (!delegate)
-    return Response::Error("Browser context management is not supported.");
+    return Response::ServerError(
+        "Browser context management is not supported.");
   if (!browser_context_id.isJust()) {
     *browser_context = delegate->GetDefaultBrowserContext();
     if (*browser_context == nullptr)
-      return Response::Error("Browser context management is not supported.");
-    return Response::OK();
+      return Response::ServerError(
+          "Browser context management is not supported.");
+    return Response::Success();
   }
 
   std::string context_id = browser_context_id.fromJust();
   for (auto* context : delegate->GetBrowserContexts()) {
     if (context->UniqueId() == context_id) {
       *browser_context = context;
-      return Response::OK();
+      return Response::Success();
     }
   }
   return Response::InvalidParams("Failed to find browser context for id " +
@@ -310,19 +312,19 @@ Response BrowserHandler::SetPermission(
     Maybe<std::string> browser_context_id) {
   BrowserContext* browser_context = nullptr;
   Response response = FindBrowserContext(browser_context_id, &browser_context);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   PermissionType type;
   Response parse_response =
       PermissionDescriptorToPermissionType(std::move(permission), &type);
-  if (!parse_response.isSuccess())
+  if (!parse_response.IsSuccess())
     return parse_response;
 
   blink::mojom::PermissionStatus permission_status;
   Response setting_response =
       PermissionSettingToPermissionStatus(setting, &permission_status);
-  if (!setting_response.isSuccess())
+  if (!setting_response.IsSuccess())
     return setting_response;
 
   PermissionControllerImpl* permission_controller =
@@ -344,7 +346,7 @@ Response BrowserHandler::SetPermission(
   }
   contexts_with_overridden_permissions_.insert(
       browser_context_id.fromMaybe(std::string()));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::GrantPermissions(
@@ -354,7 +356,7 @@ Response BrowserHandler::GrantPermissions(
     Maybe<std::string> browser_context_id) {
   BrowserContext* browser_context = nullptr;
   Response response = FindBrowserContext(browser_context_id, &browser_context);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   std::vector<PermissionType> internal_permissions;
@@ -362,7 +364,7 @@ Response BrowserHandler::GrantPermissions(
   for (const protocol::Browser::PermissionType& t : *permissions) {
     PermissionType type;
     Response type_response = FromProtocolPermissionType(t, &type);
-    if (!type_response.isSuccess())
+    if (!type_response.IsSuccess())
       return type_response;
     internal_permissions.push_back(type);
   }
@@ -386,20 +388,20 @@ Response BrowserHandler::GrantPermissions(
   }
   contexts_with_overridden_permissions_.insert(
       browser_context_id.fromMaybe(""));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::ResetPermissions(
     Maybe<std::string> browser_context_id) {
   BrowserContext* browser_context = nullptr;
   Response response = FindBrowserContext(browser_context_id, &browser_context);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   PermissionControllerImpl* permission_controller =
       PermissionControllerImpl::FromBrowserContext(browser_context);
   permission_controller->ResetOverridesForDevTools();
   contexts_with_overridden_permissions_.erase(browser_context_id.fromMaybe(""));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::GetHistogram(
@@ -416,7 +418,7 @@ Response BrowserHandler::GetHistogram(
   DCHECK(out_histogram);
   *out_histogram = Convert(*in_histogram, in_delta.fromMaybe(false));
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::GetBrowserCommandLine(
@@ -433,16 +435,16 @@ Response BrowserHandler::GetBrowserCommandLine(
       (*arguments)->emplace_back(arg);
 #endif
     }
-    return Response::OK();
+    return Response::Success();
   } else {
-    return Response::Error(
+    return Response::ServerError(
         "Command line not returned because --enable-automation not set.");
   }
 }
 
 Response BrowserHandler::Crash() {
   CHECK(false);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::CrashGpuProcess() {
@@ -451,7 +453,7 @@ Response BrowserHandler::CrashGpuProcess() {
                              if (host)
                                host->gpu_service()->Crash();
                            }));
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace protocol

content/browser/devtools/protocol/devtools_domain_handler.cc

@@ -24,7 +24,7 @@ void DevToolsDomainHandler::Wire(UberDispatcher* dispatcher) {
 }
 
 Response DevToolsDomainHandler::Disable() {
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace protocol

content/browser/devtools/protocol/devtools_mhtml_helper.cc

@@ -143,7 +143,7 @@ void DevToolsMHTMLHelper::ReportFailure(const std::string& message) {
   if (message.empty())
     callback_->sendFailure(Response::InternalError());
   else
-    callback_->sendFailure(Response::Error(message));
+    callback_->sendFailure(Response::ServerError(message));
 }
 
 void DevToolsMHTMLHelper::ReportSuccess(

content/browser/devtools/protocol/dom_handler.cc

@@ -30,7 +30,7 @@ void DOMHandler::SetRenderer(int process_host_id,
 }
 
 Response DOMHandler::Disable() {
-  return Response::OK();
+  return Response::Success();
 }
 
 Response DOMHandler::SetFileInputFiles(
@@ -39,7 +39,7 @@ Response DOMHandler::SetFileInputFiles(
     Maybe<DOM::BackendNodeId> backend_node_id,
     Maybe<String> in_object_id) {
   if (!allow_file_access_)
-    return Response::Error("Not allowed");
+    return Response::ServerError("Not allowed");
   if (host_) {
     for (const std::string& file : *files) {
       ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadFile(

content/browser/devtools/protocol/emulation_handler.cc

@@ -98,7 +98,7 @@ Response EmulationHandler::Disable() {
     device_emulation_enabled_ = false;
     UpdateDeviceEmulationState();
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response EmulationHandler::SetGeolocationOverride(
@@ -115,14 +115,14 @@ Response EmulationHandler::SetGeolocationOverride(
     geoposition->timestamp = base::Time::Now();
 
     if (!device::ValidateGeoposition(*geoposition))
-      return Response::Error("Invalid geolocation");
+      return Response::ServerError("Invalid geolocation");
 
   } else {
     geoposition->error_code =
         device::mojom::Geoposition::ErrorCode::POSITION_UNAVAILABLE;
   }
   geolocation_context->SetOverride(std::move(geoposition));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response EmulationHandler::ClearGeolocationOverride() {
@@ -131,7 +131,7 @@ Response EmulationHandler::ClearGeolocationOverride() {
 
   auto* geolocation_context = GetWebContents()->GetGeolocationContext();
   geolocation_context->ClearOverride();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response EmulationHandler::SetEmitTouchEventsForMouse(
@@ -140,7 +140,7 @@ Response EmulationHandler::SetEmitTouchEventsForMouse(
   touch_emulation_enabled_ = enabled;
   touch_emulation_configuration_ = configuration.fromMaybe("");
   UpdateTouchEventEmulationState();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response EmulationHandler::CanEmulate(bool* result) {
@@ -154,7 +154,7 @@ Response EmulationHandler::CanEmulate(bool* result) {
       *result = false;
   }
 #endif  // defined(OS_ANDROID)
-  return Response::OK();
+  return Response::Success();
 }
 
 Response EmulationHandler::SetDeviceMetricsOverride(
@@ -175,7 +175,7 @@ Response EmulationHandler::SetDeviceMetricsOverride(
   const static int max_orientation_angle = 360;
 
   if (!host_)
-    return Response::Error("Target does not support metrics override");
+    return Response::ServerError("Target does not support metrics override");
 
   if (screen_width.fromMaybe(0) < 0 || screen_height.fromMaybe(0) < 0 ||
       screen_width.fromMaybe(0) > max_size ||
@@ -261,7 +261,7 @@ Response EmulationHandler::SetDeviceMetricsOverride(
       size_changed =
           GetWebContents()->SetDeviceEmulationSize(gfx::Size(width, height));
     } else {
-      return Response::Error("Can't find the associated web contents");
+      return Response::ServerError("Can't find the associated web contents");
     }
   }
 
@@ -270,7 +270,7 @@ Response EmulationHandler::SetDeviceMetricsOverride(
     // only sent to the client once updates were applied.
     if (size_changed)
       return Response::FallThrough();
-    return Response::OK();
+    return Response::Success();
   }
 
   device_emulation_enabled_ = true;
@@ -281,15 +281,15 @@ Response EmulationHandler::SetDeviceMetricsOverride(
   // response is only sent to the client once updates were applied.
   // Unless the renderer has crashed.
   if (GetWebContents() && GetWebContents()->IsCrashed())
-    return Response::OK();
+    return Response::Success();
   return Response::FallThrough();
 }
 
 Response EmulationHandler::ClearDeviceMetricsOverride() {
   if (!device_emulation_enabled_)
-    return Response::OK();
+    return Response::Success();
   if (!host_)
-    return Response::Error("Can't find the associated web contents");
+    return Response::ServerError("Can't find the associated web contents");
   GetWebContents()->ClearDeviceEmulationSize();
   device_emulation_enabled_ = false;
   device_emulation_params_ = blink::WebDeviceEmulationParams();
@@ -298,7 +298,7 @@ Response EmulationHandler::ClearDeviceMetricsOverride() {
   // is only sent to the client once updates were applied.
   // Unless the renderer has crashed.
   if (GetWebContents()->IsCrashed())
-    return Response::OK();
+    return Response::Success();
   return Response::FallThrough();
 }
 
@@ -307,9 +307,9 @@ Response EmulationHandler::SetVisibleSize(int width, int height) {
     return Response::InvalidParams("Width and height must be non-negative");
 
   if (!host_)
-    return Response::Error("Can't find the associated web contents");
+    return Response::ServerError("Can't find the associated web contents");
   GetWebContents()->SetDeviceEmulationSize(gfx::Size(width, height));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response EmulationHandler::SetUserAgentOverride(

content/browser/devtools/protocol/fetch_handler.cc

@@ -61,7 +61,7 @@ Response ToInterceptionPatterns(
   if (!maybe_patterns.isJust()) {
     result->emplace_back("*", base::flat_set<blink::mojom::ResourceType>(),
                          DevToolsURLLoaderInterceptor::REQUEST);
-    return Response::OK();
+    return Response::Success();
   }
   Array<Fetch::RequestPattern>& patterns = *maybe_patterns.fromJust();
   for (const std::unique_ptr<Fetch::RequestPattern>& pattern : patterns) {
@@ -80,7 +80,7 @@ Response ToInterceptionPatterns(
         RequestStageToInterceptorStage(
             pattern->GetRequestStage(Fetch::RequestStageEnum::Request)));
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 bool FetchHandler::MaybeCreateProxyForInterception(
@@ -104,7 +104,7 @@ void FetchHandler::Enable(Maybe<Array<Fetch::RequestPattern>> patterns,
   }
   std::vector<DevToolsURLLoaderInterceptor::Pattern> interception_patterns;
   Response response = ToInterceptionPatterns(patterns, &interception_patterns);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(response);
     return;
   }
@@ -124,7 +124,7 @@ Response FetchHandler::Disable() {
   interceptor_.reset();
   if (was_enabled)
     update_loader_factories_callback_.Run(base::DoNothing());
-  return Response::OK();
+  return Response::Success();
 }
 
 namespace {
@@ -175,7 +175,7 @@ void FetchHandler::FailRequest(const String& requestId,
                                const String& errorReason,
                                std::unique_ptr<FailRequestCallback> callback) {
   if (!interceptor_) {
-    callback->sendFailure(Response::Error("Fetch domain is not enabled"));
+    callback->sendFailure(Response::ServerError("Fetch domain is not enabled"));
     return;
   }
   bool ok = false;
@@ -199,7 +199,7 @@ void FetchHandler::FulfillRequest(
     Maybe<String> responsePhrase,
     std::unique_ptr<FulfillRequestCallback> callback) {
   if (!interceptor_) {
-    callback->sendFailure(Response::Error("Fetch domain is not enabled"));
+    callback->sendFailure(Response::ServerError("Fetch domain is not enabled"));
     return;
   }
   std::string status_phrase =
@@ -253,7 +253,7 @@ void FetchHandler::ContinueRequest(
     Maybe<Array<Fetch::HeaderEntry>> headers,
     std::unique_ptr<ContinueRequestCallback> callback) {
   if (!interceptor_) {
-    callback->sendFailure(Response::Error("Fetch domain is not enabled"));
+    callback->sendFailure(Response::ServerError("Fetch domain is not enabled"));
     return;
   }
   std::unique_ptr<DevToolsURLLoaderInterceptor::Modifications::HeadersVector>
@@ -282,7 +282,7 @@ void FetchHandler::ContinueWithAuth(
         authChallengeResponse,
     std::unique_ptr<ContinueWithAuthCallback> callback) {
   if (!interceptor_) {
-    callback->sendFailure(Response::Error("Fetch domain is not enabled"));
+    callback->sendFailure(Response::ServerError("Fetch domain is not enabled"));
     return;
   }
   using AuthChallengeResponse =
@@ -337,8 +337,8 @@ void FetchHandler::OnResponseBodyPipeTaken(
     mojo::ScopedDataPipeConsumerHandle pipe,
     const std::string& mime_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK_EQ(response.isSuccess(), pipe.is_valid());
-  if (!response.isSuccess()) {
+  DCHECK_EQ(response.IsSuccess(), pipe.is_valid());
+  if (!response.IsSuccess()) {
     callback->sendFailure(std::move(response));
     return;
   }

content/browser/devtools/protocol/input_handler.cc

@@ -245,7 +245,7 @@ void SendSynthesizePinchGestureResponse(
   if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
     callback->sendSuccess();
   } else {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         base::StringPrintf("Synthetic pinch failed, result was %d", result)));
   }
 }
@@ -268,7 +268,7 @@ class TapGestureResponse {
       if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
         callback_->sendSuccess();
       } else {
-        callback_->sendFailure(Response::Error(
+        callback_->sendFailure(Response::ServerError(
             base::StringPrintf("Synthetic tap failed, result was %d", result)));
       }
       callback_.reset();
@@ -288,7 +288,7 @@ void SendSynthesizeScrollGestureResponse(
   if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
     callback->sendSuccess();
   } else {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         base::StringPrintf("Synthetic scroll failed, result was %d", result)));
   }
 }
@@ -299,7 +299,7 @@ void DispatchPointerActionsResponse(
   if (result == SyntheticGesture::Result::GESTURE_FINISHED) {
     callback->sendSuccess();
   } else {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         base::StringPrintf("Action sequence failed, result was %d", result)));
   }
 }
@@ -519,7 +519,7 @@ Response InputHandler::Disable() {
   ignore_input_events_ = false;
   pointer_ids_.clear();
   touch_points_.clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InputHandler::DispatchKeyEvent(
@@ -829,7 +829,7 @@ void InputHandler::DispatchWebTouchEvent(
     }
   }
   if (!ok) {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         base::StringPrintf("Exceeded maximum touch points limit of %d",
                            blink::WebTouchEvent::kTouchesLengthCap)));
     return;
@@ -1135,7 +1135,7 @@ Response InputHandler::EmulateTouchFromMouseEvent(const std::string& type,
   } else {
     host_->GetRenderWidgetHost()->ForwardMouseEvent(*mouse_event);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InputHandler::SetIgnoreInputEvents(bool ignore) {
@@ -1143,7 +1143,7 @@ Response InputHandler::SetIgnoreInputEvents(bool ignore) {
   WebContents* web_contents = WebContents::FromRenderFrameHost(host_);
   if (web_contents)
     web_contents->SetIgnoreInputEvents(ignore);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InputHandler::SynthesizePinchGesture(
@@ -1258,7 +1258,7 @@ void InputHandler::SynthesizeRepeatingScroll(
     std::unique_ptr<SynthesizeScrollGestureCallback> callback) {
   RenderWidgetHostViewBase* root_view = GetRootView();
   if (!root_view) {
-    callback->sendFailure(Response::Error("Frame was detached"));
+    callback->sendFailure(Response::ServerError("Frame was detached"));
     return;
   }
 

content/browser/devtools/protocol/inspector_handler.cc

@@ -50,11 +50,11 @@ void InspectorHandler::TargetDetached(const std::string& reason) {
 Response InspectorHandler::Enable() {
   if (host_ && !host_->IsRenderFrameLive())
     frontend_->TargetCrashed();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorHandler::Disable() {
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace protocol

content/browser/devtools/protocol/io_handler.cc

@@ -92,7 +92,7 @@ void IOHandler::ReadComplete(std::unique_ptr<ReadCallback> callback,
                              bool base64_encoded,
                              int status) {
   if (status == DevToolsIOContext::Stream::StatusFailure) {
-    callback->sendFailure(Response::Error("Read failed"));
+    callback->sendFailure(Response::ServerError("Read failed"));
     return;
   }
   bool eof = status == DevToolsIOContext::Stream::StatusEOF;
@@ -100,8 +100,9 @@ void IOHandler::ReadComplete(std::unique_ptr<ReadCallback> callback,
 }
 
 Response IOHandler::Close(const std::string& handle) {
-  return io_context_->Close(handle) ? Response::OK()
-      : Response::InvalidParams("Invalid stream handle");
+  return io_context_->Close(handle)
+             ? Response::Success()
+             : Response::InvalidParams("Invalid stream handle");
 }
 
 }  // namespace protocol

content/browser/devtools/protocol/memory_handler.cc

@@ -70,13 +70,13 @@ Response MemoryHandler::GetBrowserSamplingProfile(
                      .SetSamples(std::move(samples))
                      .SetModules(std::move(modules))
                      .Build();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response MemoryHandler::SetPressureNotificationsSuppressed(
     bool suppressed) {
   base::MemoryPressureListener::SetNotificationsSuppressed(suppressed);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response MemoryHandler::SimulatePressureNotification(
@@ -93,19 +93,20 @@ Response MemoryHandler::SimulatePressureNotification(
 
   // Simulate memory pressure notification in the browser process.
   base::MemoryPressureListener::SimulatePressureNotification(parsed_level);
-  return Response::OK();
+  return Response::Success();
 }
 
 void MemoryHandler::PrepareForLeakDetection(
     std::unique_ptr<PrepareForLeakDetectionCallback> callback) {
   if (leak_detection_callback_) {
     callback->sendFailure(
-        Response::Error("Another leak detection in progress"));
+        Response::ServerError("Another leak detection in progress"));
     return;
   }
   RenderProcessHost* process = RenderProcessHost::FromID(process_host_id_);
   if (!process) {
-    callback->sendFailure(Response::Error("No process to detect leaks in"));
+    callback->sendFailure(
+        Response::ServerError("No process to detect leaks in"));
     return;
   }
 
@@ -126,7 +127,7 @@ void MemoryHandler::OnLeakDetectionComplete(
 
 void MemoryHandler::OnLeakDetectorIsGone() {
   leak_detection_callback_->sendFailure(
-      Response::Error("Failed to run leak detection"));
+      Response::ServerError("Failed to run leak detection"));
   leak_detection_callback_.reset();
   leak_detector_.reset();
 }

content/browser/devtools/protocol/network_handler.cc

@@ -1307,7 +1307,7 @@ Response NetworkHandler::SetExtraHTTPHeaders(
 
 Response NetworkHandler::CanEmulateNetworkConditions(bool* result) {
   *result = true;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response NetworkHandler::EmulateNetworkConditions(
@@ -1807,7 +1807,7 @@ DispatchResponse NetworkHandler::SetRequestInterception(
       url_loader_interceptor_.reset();
       update_loader_factories_callback_.Run();
     }
-    return Response::OK();
+    return Response::Success();
   }
 
   std::vector<DevToolsURLLoaderInterceptor::Pattern> interceptor_patterns;
@@ -1839,7 +1839,7 @@ DispatchResponse NetworkHandler::SetRequestInterception(
   } else {
     url_loader_interceptor_->SetPatterns(interceptor_patterns, true);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 void NetworkHandler::ContinueInterceptedRequest(
@@ -1963,7 +1963,7 @@ void NetworkHandler::TakeResponseBodyForInterceptionAsStream(
                        weak_factory_.GetWeakPtr(), std::move(callback)));
     return;
   }
-  callback->sendFailure(Response::Error(
+  callback->sendFailure(Response::ServerError(
       "Network.takeResponseBodyForInterceptionAsStream is only "
       "currently supported with --enable-features=NetworkService"));
 }
@@ -1974,8 +1974,8 @@ void NetworkHandler::OnResponseBodyPipeTaken(
     mojo::ScopedDataPipeConsumerHandle pipe,
     const std::string& mime_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK_EQ(response.isSuccess(), pipe.is_valid());
-  if (!response.isSuccess()) {
+  DCHECK_EQ(response.IsSuccess(), pipe.is_valid());
+  if (!response.IsSuccess()) {
     callback->sendFailure(std::move(response));
     return;
   }

content/browser/devtools/protocol/page_handler.cc

@@ -370,20 +370,20 @@ Response PageHandler::Disable() {
 Response PageHandler::Crash() {
   WebContents* web_contents = WebContents::FromRenderFrameHost(host_);
   if (!web_contents)
-    return Response::Error("Not attached to a page");
+    return Response::ServerError("Not attached to a page");
   if (web_contents->IsCrashed())
-    return Response::Error("The target has already crashed");
+    return Response::ServerError("The target has already crashed");
   if (host_->frame_tree_node()->navigation_request())
-    return Response::Error("Page has pending navigations, not killing");
+    return Response::ServerError("Page has pending navigations, not killing");
   return Response::FallThrough();
 }
 
 Response PageHandler::Close() {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::Error("Not attached to a page");
+    return Response::ServerError("Not attached to a page");
   web_contents->DispatchBeforeUnload(false /* auto_cancel */);
-  return Response::OK();
+  return Response::Success();
 }
 
 void PageHandler::Reload(Maybe<bool> bypassCache,
@@ -442,7 +442,8 @@ void PageHandler::Navigate(const std::string& url,
                            std::unique_ptr<NavigateCallback> callback) {
   GURL gurl(url);
   if (!gurl.is_valid()) {
-    callback->sendFailure(Response::Error("Cannot navigate to invalid URL"));
+    callback->sendFailure(
+        Response::ServerError("Cannot navigate to invalid URL"));
     return;
   }
 
@@ -497,7 +498,8 @@ void PageHandler::Navigate(const std::string& url,
   }
 
   if (!frame_tree_node) {
-    callback->sendFailure(Response::Error("No frame with given id found"));
+    callback->sendFailure(
+        Response::ServerError("No frame with given id found"));
     return;
   }
 
@@ -600,7 +602,7 @@ Response PageHandler::GetNavigationHistory(
             .SetTransitionType(TransitionTypeName(entry->GetTransitionType()))
             .Build());
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response PageHandler::NavigateToHistoryEntry(int entry_id) {
@@ -612,7 +614,7 @@ Response PageHandler::NavigateToHistoryEntry(int entry_id) {
   for (int i = 0; i != controller.GetEntryCount(); ++i) {
     if (controller.GetEntryAtIndex(i)->GetUniqueID() == entry_id) {
       controller.GoToIndex(i);
-      return Response::OK();
+      return Response::Success();
     }
   }
 
@@ -630,7 +632,7 @@ Response PageHandler::ResetNavigationHistory() {
 
   NavigationController& controller = web_contents->GetController();
   controller.DeleteNavigationEntries(base::BindRepeating(&ReturnTrue));
-  return Response::OK();
+  return Response::Success();
 }
 
 void PageHandler::CaptureSnapshot(
@@ -638,7 +640,7 @@ void PageHandler::CaptureSnapshot(
     std::unique_ptr<CaptureSnapshotCallback> callback) {
   std::string snapshot_format = format.fromMaybe(kMhtml);
   if (snapshot_format != kMhtml) {
-    callback->sendFailure(Response::Error("Unsupported snapshot format"));
+    callback->sendFailure(Response::ServerError("Unsupported snapshot format"));
     return;
   }
   DevToolsMHTMLHelper::Capture(weak_factory_.GetWeakPtr(), std::move(callback));
@@ -658,12 +660,12 @@ void PageHandler::CaptureScreenshot(
   if (clip.isJust()) {
     if (clip.fromJust()->GetWidth() == 0) {
       callback->sendFailure(
-          Response::Error("Cannot take screenshot with 0 width."));
+          Response::ServerError("Cannot take screenshot with 0 width."));
       return;
     }
     if (clip.fromJust()->GetHeight() == 0) {
       callback->sendFailure(
-          Response::Error("Cannot take screenshot with 0 height."));
+          Response::ServerError("Cannot take screenshot with 0 height."));
       return;
     }
   }
@@ -800,7 +802,7 @@ void PageHandler::PrintToPDF(Maybe<bool> landscape,
                              Maybe<bool> prefer_css_page_size,
                              Maybe<String> transfer_mode,
                              std::unique_ptr<PrintToPDFCallback> callback) {
-  callback->sendFailure(Response::Error("PrintToPDF is not implemented"));
+  callback->sendFailure(Response::ServerError("PrintToPDF is not implemented"));
   return;
 }
 
@@ -871,7 +873,7 @@ Response PageHandler::StopScreencast() {
 Response PageHandler::ScreencastFrameAck(int session_id) {
   if (session_id == session_id_)
     --frames_in_flight_;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response PageHandler::HandleJavaScriptDialog(bool accept,
@@ -899,7 +901,7 @@ Response PageHandler::HandleJavaScriptDialog(bool accept,
     }
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response PageHandler::BringToFront() {
@@ -907,7 +909,7 @@ Response PageHandler::BringToFront() {
   if (wc) {
     wc->Activate();
     wc->Focus();
-    return Response::OK();
+    return Response::Success();
   }
   return Response::InternalError();
 }
@@ -915,7 +917,7 @@ Response PageHandler::BringToFront() {
 Response PageHandler::SetDownloadBehavior(const std::string& behavior,
                                           Maybe<std::string> download_path) {
   if (!allow_set_download_behavior_)
-    return Response::Error("Not allowed");
+    return Response::ServerError("Not allowed");
 
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
@@ -923,12 +925,12 @@ Response PageHandler::SetDownloadBehavior(const std::string& behavior,
 
   if (behavior == Page::SetDownloadBehavior::BehaviorEnum::Allow &&
       !download_path.isJust())
-    return Response::Error("downloadPath not provided");
+    return Response::ServerError("downloadPath not provided");
 
   if (behavior == Page::SetDownloadBehavior::BehaviorEnum::Default) {
     DevToolsDownloadManagerHelper::RemoveFromWebContents(web_contents);
     download_manager_delegate_ = nullptr;
-    return Response::OK();
+    return Response::Success();
   }
 
   // Override download manager delegate.
@@ -953,14 +955,14 @@ Response PageHandler::SetDownloadBehavior(const std::string& behavior,
     download_helper->SetDownloadPath(download_path.fromJust());
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void PageHandler::GetAppManifest(
     std::unique_ptr<GetAppManifestCallback> callback) {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents || !web_contents->GetManifestManagerHost()) {
-    callback->sendFailure(Response::Error("Cannot retrieve manifest"));
+    callback->sendFailure(Response::ServerError("Cannot retrieve manifest"));
     return;
   }
   web_contents->GetManifestManagerHost()->RequestManifestDebugInfo(
@@ -1115,7 +1117,8 @@ void PageHandler::ScreenshotCaptured(
   }
 
   if (image.IsEmpty()) {
-    callback->sendFailure(Response::Error("Unable to capture screenshot"));
+    callback->sendFailure(
+        Response::ServerError("Unable to capture screenshot"));
     return;
   }
 
@@ -1171,25 +1174,25 @@ Response PageHandler::StopLoading() {
   if (!web_contents)
     return Response::InternalError();
   web_contents->Stop();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response PageHandler::SetWebLifecycleState(const std::string& state) {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
-    return Response::Error("Not attached to a page");
+    return Response::ServerError("Not attached to a page");
   if (state == Page::SetWebLifecycleState::StateEnum::Frozen) {
     // TODO(fmeawad): Instead of forcing a visibility change, only allow
     // freezing a page if it was already hidden.
     web_contents->WasHidden();
     web_contents->SetPageFrozen(true);
-    return Response::OK();
+    return Response::Success();
   }
   if (state == Page::SetWebLifecycleState::StateEnum::Active) {
     web_contents->SetPageFrozen(false);
-    return Response::OK();
+    return Response::Success();
   }
-  return Response::Error("Unidentified lifecycle state");
+  return Response::ServerError("Unidentified lifecycle state");
 }
 
 void PageHandler::GetInstallabilityErrors(

content/browser/devtools/protocol/schema_handler.cc

@@ -39,7 +39,7 @@ Response SchemaHandler::GetDomains(
     (*domains)->emplace_back(
         Schema::Domain::Create().SetName(domain).SetVersion(kVersion).Build());
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace protocol

content/browser/devtools/protocol/security_handler.cc

@@ -242,7 +242,7 @@ Response SecurityHandler::Enable() {
   if (host_)
     AttachToRenderFrameHost();
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response SecurityHandler::Disable() {
@@ -250,25 +250,25 @@ Response SecurityHandler::Disable() {
   cert_error_override_mode_ = CertErrorOverrideMode::kDisabled;
   WebContentsObserver::Observe(nullptr);
   FlushPendingCertificateErrorNotifications();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response SecurityHandler::HandleCertificateError(int event_id,
                                                  const String& action) {
   if (cert_error_callbacks_.find(event_id) == cert_error_callbacks_.end()) {
-    return Response::Error(
+    return Response::ServerError(
         String("Unknown event id: " + std::to_string(event_id)));
   }
   content::CertificateRequestResultType type =
       content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL;
-  Response response = Response::OK();
+  Response response = Response::Success();
   if (action == Security::CertificateErrorActionEnum::Continue) {
     type = content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE;
   } else if (action == Security::CertificateErrorActionEnum::Cancel) {
     type = content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL;
   } else {
-    response =
-        Response::Error(String("Unknown Certificate Error Action: " + action));
+    response = Response::ServerError(
+        String("Unknown Certificate Error Action: " + action));
   }
   std::move(cert_error_callbacks_[event_id]).Run(type);
   cert_error_callbacks_.erase(event_id);
@@ -278,26 +278,28 @@ Response SecurityHandler::HandleCertificateError(int event_id,
 Response SecurityHandler::SetOverrideCertificateErrors(bool override) {
   if (override) {
     if (!enabled_)
-      return Response::Error("Security domain not enabled");
+      return Response::ServerError("Security domain not enabled");
     if (cert_error_override_mode_ == CertErrorOverrideMode::kIgnoreAll)
-      return Response::Error("Certificate errors are already being ignored.");
+      return Response::ServerError(
+          "Certificate errors are already being ignored.");
     cert_error_override_mode_ = CertErrorOverrideMode::kHandleEvents;
   } else {
     cert_error_override_mode_ = CertErrorOverrideMode::kDisabled;
     FlushPendingCertificateErrorNotifications();
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response SecurityHandler::SetIgnoreCertificateErrors(bool ignore) {
   if (ignore) {
     if (cert_error_override_mode_ == CertErrorOverrideMode::kHandleEvents)
-      return Response::Error("Certificate errors are already overridden.");
+      return Response::ServerError(
+          "Certificate errors are already overridden.");
     cert_error_override_mode_ = CertErrorOverrideMode::kIgnoreAll;
   } else {
     cert_error_override_mode_ = CertErrorOverrideMode::kDisabled;
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace protocol

content/browser/devtools/protocol/service_worker_handler.cc

@@ -103,11 +103,11 @@ void GetDevToolsRouteInfoOnCoreThread(
 }
 
 Response CreateDomainNotEnabledErrorResponse() {
-  return Response::Error("ServiceWorker domain not enabled");
+  return Response::ServerError("ServiceWorker domain not enabled");
 }
 
 Response CreateContextErrorResponse() {
-  return Response::Error("Could not connect to the context");
+  return Response::ServerError("Could not connect to the context");
 }
 
 Response CreateInvalidVersionIdErrorResponse() {
@@ -213,7 +213,7 @@ void ServiceWorkerHandler::SetRenderer(int process_host_id,
 
 Response ServiceWorkerHandler::Enable() {
   if (enabled_)
-    return Response::OK();
+    return Response::Success();
   if (!context_)
     return CreateContextErrorResponse();
   enabled_ = true;
@@ -228,19 +228,19 @@ Response ServiceWorkerHandler::Enable() {
                           weak_factory_.GetWeakPtr()));
   context_watcher_->Start();
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::Disable() {
   if (!enabled_)
-    return Response::OK();
+    return Response::Success();
   enabled_ = false;
 
   ClearForceUpdate();
   DCHECK(context_watcher_);
   context_watcher_->Stop();
   context_watcher_ = nullptr;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::Unregister(const std::string& scope_url) {
@@ -249,7 +249,7 @@ Response ServiceWorkerHandler::Unregister(const std::string& scope_url) {
   if (!context_)
     return CreateContextErrorResponse();
   context_->UnregisterServiceWorker(GURL(scope_url), base::DoNothing());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::StartWorker(const std::string& scope_url) {
@@ -258,7 +258,7 @@ Response ServiceWorkerHandler::StartWorker(const std::string& scope_url) {
   if (!context_)
     return CreateContextErrorResponse();
   context_->StartServiceWorker(GURL(scope_url), base::DoNothing());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::SkipWaiting(const std::string& scope_url) {
@@ -267,7 +267,7 @@ Response ServiceWorkerHandler::SkipWaiting(const std::string& scope_url) {
   if (!context_)
     return CreateContextErrorResponse();
   context_->SkipWaitingWorker(GURL(scope_url));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::StopWorker(const std::string& version_id) {
@@ -281,7 +281,7 @@ Response ServiceWorkerHandler::StopWorker(const std::string& version_id) {
   RunOrPostTaskOnThread(
       FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
       base::BindOnce(&StopServiceWorkerOnCoreThread, context_, id));
-  return Response::OK();
+  return Response::Success();
 }
 
 void ServiceWorkerHandler::StopAllWorkers(
@@ -305,7 +305,7 @@ Response ServiceWorkerHandler::UpdateRegistration(
   if (!context_)
     return CreateContextErrorResponse();
   context_->UpdateRegistration(GURL(scope_url));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::InspectWorker(const std::string& version_id) {
@@ -323,7 +323,7 @@ Response ServiceWorkerHandler::InspectWorker(const std::string& version_id) {
           &GetDevToolsRouteInfoOnCoreThread, context_, id,
           base::BindOnce(&ServiceWorkerHandler::OpenNewDevToolsWindow,
                          weak_factory_.GetWeakPtr())));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::SetForceUpdateOnPageLoad(
@@ -331,7 +331,7 @@ Response ServiceWorkerHandler::SetForceUpdateOnPageLoad(
   if (!context_)
     return CreateContextErrorResponse();
   context_->SetForceUpdateOnPageLoad(force_update_on_page_load);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::DeliverPushMessage(
@@ -353,7 +353,7 @@ Response ServiceWorkerHandler::DeliverPushMessage(
       std::move(payload),
       base::BindOnce([](blink::mojom::PushDeliveryStatus status) {}));
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::DispatchSyncEvent(
@@ -376,7 +376,7 @@ Response ServiceWorkerHandler::DispatchSyncEvent(
                         base::BindOnce(&DispatchSyncEventOnCoreThread, context_,
                                        base::WrapRefCounted(sync_context),
                                        GURL(origin), id, tag, last_chance));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response ServiceWorkerHandler::DispatchPeriodicSyncEvent(
@@ -399,7 +399,7 @@ Response ServiceWorkerHandler::DispatchPeriodicSyncEvent(
       base::BindOnce(&DispatchPeriodicSyncEventOnCoreThread, context_,
                      base::WrapRefCounted(sync_context), GURL(origin), id,
                      tag));
-  return Response::OK();
+  return Response::Success();
 }
 
 void ServiceWorkerHandler::OpenNewDevToolsWindow(int process_id,

content/browser/devtools/protocol/storage_handler.cc

@@ -66,7 +66,7 @@ void ReportUsageAndQuotaDataOnUIThread(
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (code != blink::mojom::QuotaStatusCode::kOk) {
     return callback->sendFailure(
-        Response::Error("Quota information is not available"));
+        Response::ServerError("Quota information is not available"));
   }
 
   auto usageList = std::make_unique<Array<Storage::UsageForType>>();
@@ -268,7 +268,7 @@ void StorageHandler::SetRenderer(int process_host_id,
 Response StorageHandler::Disable() {
   cache_storage_observer_.reset();
   indexed_db_observer_.reset();
-  return Response::OK();
+  return Response::Success();
 }
 
 void StorageHandler::GetCookies(Maybe<std::string> browser_context_id,
@@ -276,7 +276,7 @@ void StorageHandler::GetCookies(Maybe<std::string> browser_context_id,
   StoragePartition* storage_partition = nullptr;
   Response response = StorageHandler::FindStoragePartition(browser_context_id,
                                                            &storage_partition);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(std::move(response));
     return;
   }
@@ -297,7 +297,7 @@ void StorageHandler::SetCookies(
   StoragePartition* storage_partition = nullptr;
   Response response = StorageHandler::FindStoragePartition(browser_context_id,
                                                            &storage_partition);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(std::move(response));
     return;
   }
@@ -322,7 +322,7 @@ void StorageHandler::ClearCookies(
   StoragePartition* storage_partition = nullptr;
   Response response = StorageHandler::FindStoragePartition(browser_context_id,
                                                            &storage_partition);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(std::move(response));
     return;
   }
@@ -387,7 +387,7 @@ void StorageHandler::GetUsageAndQuota(
   GURL origin_url(origin);
   if (!origin_url.is_valid()) {
     return callback->sendFailure(
-        Response::Error(origin + " is not a valid URL"));
+        Response::ServerError(origin + " is not a valid URL"));
   }
 
   storage::QuotaManager* manager = storage_partition_->GetQuotaManager();
@@ -406,7 +406,7 @@ Response StorageHandler::TrackCacheStorageForOrigin(const std::string& origin) {
     return Response::InvalidParams(origin + " is not a valid URL");
 
   GetCacheStorageObserver()->TrackOrigin(url::Origin::Create(origin_url));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response StorageHandler::UntrackCacheStorageForOrigin(
@@ -419,7 +419,7 @@ Response StorageHandler::UntrackCacheStorageForOrigin(
     return Response::InvalidParams(origin + " is not a valid URL");
 
   GetCacheStorageObserver()->UntrackOrigin(url::Origin::Create(origin_url));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response StorageHandler::TrackIndexedDBForOrigin(const std::string& origin) {
@@ -431,7 +431,7 @@ Response StorageHandler::TrackIndexedDBForOrigin(const std::string& origin) {
     return Response::InvalidParams(origin + " is not a valid URL");
 
   GetIndexedDBObserver()->TrackOrigin(url::Origin::Create(origin_url));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response StorageHandler::UntrackIndexedDBForOrigin(const std::string& origin) {
@@ -443,7 +443,7 @@ Response StorageHandler::UntrackIndexedDBForOrigin(const std::string& origin) {
     return Response::InvalidParams(origin + " is not a valid URL");
 
   GetIndexedDBObserver()->UntrackOrigin(url::Origin::Create(origin_url));
-  return Response::OK();
+  return Response::Success();
 }
 
 StorageHandler::CacheStorageObserver*
@@ -498,13 +498,13 @@ Response StorageHandler::FindStoragePartition(
   BrowserContext* browser_context = nullptr;
   Response response =
       BrowserHandler::FindBrowserContext(browser_context_id, &browser_context);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   *storage_partition =
       BrowserContext::GetDefaultStoragePartition(browser_context);
   if (!*storage_partition)
     return Response::InternalError();
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace protocol

content/browser/devtools/protocol/target_handler.cc

@@ -548,7 +548,7 @@ Response TargetHandler::Disable() {
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (!delegate)
-    return Response::OK();
+    return Response::Success();
 
   if (dispose_on_detach_context_ids_.size()) {
     for (auto* context : delegate->GetBrowserContexts()) {
@@ -560,7 +560,7 @@ Response TargetHandler::Disable() {
     }
     dispose_on_detach_context_ids_.clear();
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 void TargetHandler::DidFinishNavigation() {
@@ -672,19 +672,20 @@ Response TargetHandler::FindSession(Maybe<std::string> session_id,
     if (it == attached_sessions_.end())
       return Response::InvalidParams("No session with given id");
     *session = it->second.get();
-    return Response::OK();
+    return Response::Success();
   }
   if (target_id.isJust()) {
     for (auto& it : attached_sessions_) {
       if (it.second->IsAttachedTo(target_id.fromJust())) {
         if (*session)
-          return Response::Error("Multiple sessions attached, specify id.");
+          return Response::ServerError(
+              "Multiple sessions attached, specify id.");
         *session = it.second.get();
       }
     }
     if (!*session)
       return Response::InvalidParams("No session for given target id");
-    return Response::OK();
+    return Response::Success();
   }
   return Response::InvalidParams("Session id must be specified");
 }
@@ -693,14 +694,14 @@ Response TargetHandler::FindSession(Maybe<std::string> session_id,
 
 Response TargetHandler::SetDiscoverTargets(bool discover) {
   if (access_mode_ == AccessMode::kAutoAttachOnly)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   if (discover_ == discover)
-    return Response::OK();
+    return Response::Success();
   discover_ = discover;
   UpdateAgentHostObserver();
   if (!discover_)
     reported_hosts_.clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 void TargetHandler::SetAutoAttach(
@@ -720,14 +721,14 @@ void TargetHandler::SetAutoAttach(
 
 Response TargetHandler::SetRemoteLocations(
     std::unique_ptr<protocol::Array<Target::RemoteLocation>>) {
-  return Response::Error("Not supported");
+  return Response::ServerError("Not supported");
 }
 
 Response TargetHandler::AttachToTarget(const std::string& target_id,
                                        Maybe<bool> flatten,
                                        std::string* out_session_id) {
   if (access_mode_ == AccessMode::kAutoAttachOnly)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   // TODO(dgozman): only allow reported hosts.
   scoped_refptr<DevToolsAgentHost> agent_host =
       DevToolsAgentHost::GetForId(target_id);
@@ -735,30 +736,30 @@ Response TargetHandler::AttachToTarget(const std::string& target_id,
     return Response::InvalidParams("No target with given id found");
   *out_session_id =
       Session::Attach(this, agent_host.get(), false, flatten.fromMaybe(false));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::AttachToBrowserTarget(std::string* out_session_id) {
   if (access_mode_ != AccessMode::kBrowser)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   scoped_refptr<DevToolsAgentHost> agent_host =
       DevToolsAgentHost::CreateForBrowser(
           nullptr, DevToolsAgentHost::CreateServerSocketCallback());
   *out_session_id = Session::Attach(this, agent_host.get(), false, true);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::DetachFromTarget(Maybe<std::string> session_id,
                                          Maybe<std::string> target_id) {
   if (access_mode_ == AccessMode::kAutoAttachOnly)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   Session* session = nullptr;
   Response response =
       FindSession(std::move(session_id), std::move(target_id), &session);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   session->Detach(false);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::SendMessageToTarget(const std::string& message,
@@ -767,22 +768,22 @@ Response TargetHandler::SendMessageToTarget(const std::string& message,
   Session* session = nullptr;
   Response response =
       FindSession(std::move(session_id), std::move(target_id), &session);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (session->flatten_protocol_) {
-    return Response::Error(
+    return Response::ServerError(
         "When using flat protocol, messages are routed to the target "
         "via the sessionId attribute.");
   }
   session->SendMessageToAgentHost(base::as_bytes(base::make_span(message)));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::GetTargetInfo(
     Maybe<std::string> maybe_target_id,
     std::unique_ptr<Target::TargetInfo>* target_info) {
   if (access_mode_ == AccessMode::kAutoAttachOnly)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   const std::string& target_id =
       maybe_target_id.isJust() ? maybe_target_id.fromJust() : owner_target_id_;
   // TODO(dgozman): only allow reported hosts.
@@ -791,31 +792,31 @@ Response TargetHandler::GetTargetInfo(
   if (!agent_host)
     return Response::InvalidParams("No target with given id found");
   *target_info = CreateInfo(agent_host.get());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::ActivateTarget(const std::string& target_id) {
   if (access_mode_ == AccessMode::kAutoAttachOnly)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   // TODO(dgozman): only allow reported hosts.
   scoped_refptr<DevToolsAgentHost> agent_host(
       DevToolsAgentHost::GetForId(target_id));
   if (!agent_host)
     return Response::InvalidParams("No target with given id found");
   agent_host->Activate();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::CloseTarget(const std::string& target_id,
                                     bool* out_success) {
   if (access_mode_ == AccessMode::kAutoAttachOnly)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   scoped_refptr<DevToolsAgentHost> agent_host =
       DevToolsAgentHost::GetForId(target_id);
   if (!agent_host)
     return Response::InvalidParams("No target with given id found");
   *out_success = agent_host->Close();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::ExposeDevToolsProtocol(
@@ -829,17 +830,17 @@ Response TargetHandler::ExposeDevToolsProtocol(
     return Response::InvalidParams("No target with given id found");
 
   if (g_browser_to_page_connectors.Get()[agent_host.get()]) {
-    return Response::Error(base::StringPrintf(
+    return Response::ServerError(base::StringPrintf(
         "Target with id %s is already granted remote debugging bindings.",
         target_id.c_str()));
   }
   if (!agent_host->GetWebContents()) {
-    return Response::Error(
+    return Response::ServerError(
         "RemoteDebuggingBinding can be granted only to page targets");
   }
 
   new BrowserToPageConnector(binding_name.fromMaybe("cdp"), agent_host.get());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::CreateTarget(const std::string& url,
@@ -851,27 +852,27 @@ Response TargetHandler::CreateTarget(const std::string& url,
                                      Maybe<bool> background,
                                      std::string* out_target_id) {
   if (access_mode_ == AccessMode::kAutoAttachOnly)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (!delegate)
-    return Response::Error("Not supported");
+    return Response::ServerError("Not supported");
   scoped_refptr<content::DevToolsAgentHost> agent_host =
       delegate->CreateNewTarget(GURL(url));
   if (!agent_host)
-    return Response::Error("Not supported");
+    return Response::ServerError("Not supported");
   *out_target_id = agent_host->GetId();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::GetTargets(
     std::unique_ptr<protocol::Array<Target::TargetInfo>>* target_infos) {
   if (access_mode_ == AccessMode::kAutoAttachOnly)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   *target_infos = std::make_unique<protocol::Array<Target::TargetInfo>>();
   for (const auto& host : DevToolsAgentHost::GetOrCreateAll())
     (*target_infos)->emplace_back(CreateInfo(host.get()));
-  return Response::OK();
+  return Response::Success();
 }
 
 // -------------- DevToolsAgentHostObserver -----------------
@@ -951,48 +952,50 @@ protocol::Response TargetHandler::CreateBrowserContext(
     Maybe<bool> dispose_on_detach,
     std::string* out_context_id) {
   if (access_mode_ != AccessMode::kBrowser)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (!delegate)
-    return Response::Error("Browser context management is not supported.");
+    return Response::ServerError(
+        "Browser context management is not supported.");
   BrowserContext* context = delegate->CreateBrowserContext();
   if (!context)
-    return Response::Error("Failed to create browser context.");
+    return Response::ServerError("Failed to create browser context.");
   *out_context_id = context->UniqueId();
   if (dispose_on_detach.fromMaybe(false))
     dispose_on_detach_context_ids_.insert(*out_context_id);
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response TargetHandler::GetBrowserContexts(
     std::unique_ptr<protocol::Array<protocol::String>>* browser_context_ids) {
   if (access_mode_ != AccessMode::kBrowser)
-    return Response::Error(kNotAllowedError);
+    return Response::ServerError(kNotAllowedError);
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (!delegate)
-    return Response::Error("Browser context management is not supported.");
+    return Response::ServerError(
+        "Browser context management is not supported.");
   std::vector<content::BrowserContext*> contexts =
       delegate->GetBrowserContexts();
   *browser_context_ids = std::make_unique<protocol::Array<protocol::String>>();
   for (auto* context : contexts)
     (*browser_context_ids)->emplace_back(context->UniqueId());
-  return Response::OK();
+  return Response::Success();
 }
 
 void TargetHandler::DisposeBrowserContext(
     const std::string& context_id,
     std::unique_ptr<DisposeBrowserContextCallback> callback) {
   if (access_mode_ != AccessMode::kBrowser) {
-    callback->sendFailure(Response::Error(kNotAllowedError));
+    callback->sendFailure(Response::ServerError(kNotAllowedError));
     return;
   }
   DevToolsManagerDelegate* delegate =
       DevToolsManager::GetInstance()->delegate();
   if (!delegate) {
     callback->sendFailure(
-        Response::Error("Browser context management is not supported."));
+        Response::ServerError("Browser context management is not supported."));
     return;
   }
   std::vector<content::BrowserContext*> contexts =
@@ -1004,7 +1007,7 @@ void TargetHandler::DisposeBrowserContext(
                    });
   if (context_it == contexts.end()) {
     callback->sendFailure(
-        Response::Error("Failed to find context with id " + context_id));
+        Response::ServerError("Failed to find context with id " + context_id));
     return;
   }
   dispose_on_detach_context_ids_.erase(context_id);
@@ -1016,7 +1019,7 @@ void TargetHandler::DisposeBrowserContext(
             if (success)
               callback->sendSuccess();
             else
-              callback->sendFailure(Response::Error(error));
+              callback->sendFailure(Response::ServerError(error));
           },
           std::move(callback)));
 }

content/browser/devtools/protocol/tethering_handler.cc

@@ -291,7 +291,7 @@ void TetheringHandler::TetheringImpl::Bind(
     base::PostTask(
         FROM_HERE, {BrowserThread::UI},
         base::BindOnce(&BindCallback::sendFailure, std::move(callback),
-                       Response::Error("Port already bound")));
+                       Response::ServerError("Port already bound")));
     return;
   }
 
@@ -303,7 +303,7 @@ void TetheringHandler::TetheringImpl::Bind(
     base::PostTask(
         FROM_HERE, {BrowserThread::UI},
         base::BindOnce(&BindCallback::sendFailure, std::move(callback),
-                       Response::Error("Could not bind port")));
+                       Response::ServerError("Could not bind port")));
     return;
   }
 
@@ -386,7 +386,7 @@ void TetheringHandler::Bind(
 
   if (!Activate()) {
     callback->sendFailure(
-        Response::Error("Tethering is used by another connection"));
+        Response::ServerError("Tethering is used by another connection"));
     return;
   }
 
@@ -400,7 +400,7 @@ void TetheringHandler::Unbind(
     int port, std::unique_ptr<UnbindCallback> callback) {
   if (!Activate()) {
     callback->sendFailure(
-        Response::Error("Tethering is used by another connection"));
+        Response::ServerError("Tethering is used by another connection"));
     return;
   }
 

content/browser/devtools/protocol/tracing_handler.cc

@@ -569,7 +569,7 @@ void TracingHandler::Wire(UberDispatcher* dispatcher) {
 Response TracingHandler::Disable() {
   if (session_)
     StopTracing(nullptr, "");
-  return Response::OK();
+  return Response::Success();
 }
 
 namespace {
@@ -710,7 +710,7 @@ void TracingHandler::Start(Maybe<std::string> categories,
       transfer_format.fromMaybe("") == Tracing::StreamFormatEnum::Proto;
 
   if (proto_format && !return_as_stream) {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         "Proto format is only supported when using stream transfer mode."));
     return;
   }
@@ -724,7 +724,7 @@ void TracingHandler::Start(Maybe<std::string> categories,
       gzip_compression_ = gzip_compression;
       proto_format_ = proto_format;
     }
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         "Tracing has already been started (possibly in another tab)."));
     return;
   }
@@ -774,7 +774,7 @@ void TracingHandler::StartTracingWithGpuPid(
     base::ProcessId gpu_pid) {
   // Check if tracing was stopped in mid-air.
   if (!did_initiate_recording_) {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         "Tracing was stopped before start has been completed."));
     return;
   }
@@ -841,10 +841,10 @@ void TracingHandler::OnProcessReady(RenderProcessHost* process_host) {
 
 Response TracingHandler::End() {
   if (!session_)
-    return Response::Error("Tracing is not started");
+    return Response::ServerError("Tracing is not started");
 
   if (session_->HasTracingFailed())
-    return Response::Error("Tracing failed");
+    return Response::ServerError("Tracing failed");
 
   scoped_refptr<TracingController::TraceDataEndpoint> endpoint;
   if (return_as_stream_) {
@@ -864,7 +864,7 @@ Response TracingHandler::End() {
     StopTracing(endpoint, tracing::mojom::kChromeTraceEventLabel);
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void TracingHandler::GetCategories(
@@ -878,7 +878,7 @@ void TracingHandler::GetCategories(
 void TracingHandler::OnRecordingEnabled(
     std::unique_ptr<StartCallback> callback) {
   if (!did_initiate_recording_) {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         "Tracing was stopped before start has been completed."));
     return;
   }
@@ -921,7 +921,7 @@ void TracingHandler::RequestMemoryDump(
     Maybe<bool> deterministic,
     std::unique_ptr<RequestMemoryDumpCallback> callback) {
   if (!IsTracing()) {
-    callback->sendFailure(Response::Error("Tracing is not started"));
+    callback->sendFailure(Response::ServerError("Tracing is not started"));
     return;
   }
 
@@ -970,9 +970,9 @@ void TracingHandler::OnFrameFromVideoConsumer(
 
 Response TracingHandler::RecordClockSyncMarker(const std::string& sync_id) {
   if (!IsTracing())
-    return Response::Error("Tracing is not started");
+    return Response::ServerError("Tracing is not started");
   TRACE_EVENT_CLOCK_SYNC_RECEIVER(sync_id);
-  return Response::OK();
+  return Response::Success();
 }
 
 void TracingHandler::SetupTimer(double usage_reporting_interval) {

content/browser/devtools/protocol/webauthn_handler.cc

@@ -107,14 +107,14 @@ void WebAuthnHandler::Wire(UberDispatcher* dispatcher) {
 
 Response WebAuthnHandler::Enable() {
   if (!frame_host_)
-    return Response::Error(kDevToolsNotAttached);
+    return Response::ServerError(kDevToolsNotAttached);
 
   AuthenticatorEnvironmentImpl::GetInstance()->EnableVirtualAuthenticatorFor(
       frame_host_->frame_tree_node());
   virtual_discovery_factory_ =
       AuthenticatorEnvironmentImpl::GetInstance()->GetVirtualFactoryFor(
           frame_host_->frame_tree_node());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::Disable() {
@@ -123,14 +123,14 @@ Response WebAuthnHandler::Disable() {
         frame_host_->frame_tree_node());
   }
   virtual_discovery_factory_ = nullptr;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::AddVirtualAuthenticator(
     std::unique_ptr<WebAuthn::VirtualAuthenticatorOptions> options,
     String* out_authenticator_id) {
   if (!virtual_discovery_factory_)
-    return Response::Error(kVirtualEnvironmentNotEnabled);
+    return Response::ServerError(kVirtualEnvironmentNotEnabled);
 
   auto transport =
       device::ConvertToFidoTransportProtocol(options->GetTransport());
@@ -154,7 +154,7 @@ Response WebAuthnHandler::AddVirtualAuthenticator(
       options->GetHasResidentKey(false /* default */),
       options->GetHasUserVerification(false /* default */));
   if (!authenticator)
-    return Response::Error(kErrorCreatingAuthenticator);
+    return Response::ServerError(kErrorCreatingAuthenticator);
 
   authenticator->SetUserPresence(
       options->GetAutomaticPresenceSimulation(true /* default */));
@@ -162,18 +162,18 @@ Response WebAuthnHandler::AddVirtualAuthenticator(
       options->GetIsUserVerified(false /* default */));
 
   *out_authenticator_id = authenticator->unique_id();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::RemoveVirtualAuthenticator(
     const String& authenticator_id) {
   if (!virtual_discovery_factory_)
-    return Response::Error(kVirtualEnvironmentNotEnabled);
+    return Response::ServerError(kVirtualEnvironmentNotEnabled);
 
   if (!virtual_discovery_factory_->RemoveAuthenticator(authenticator_id))
     return Response::InvalidParams(kAuthenticatorNotFound);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::AddCredential(
@@ -181,7 +181,7 @@ Response WebAuthnHandler::AddCredential(
     std::unique_ptr<WebAuthn::Credential> credential) {
   VirtualAuthenticator* authenticator;
   Response response = FindAuthenticator(authenticator_id, &authenticator);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Binary user_handle = credential->GetUserHandle(Binary());
@@ -217,9 +217,9 @@ Response WebAuthnHandler::AddCredential(
   }
 
   if (!credential_created)
-    return Response::Error(kCouldNotCreateCredential);
+    return Response::ServerError(kCouldNotCreateCredential);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::GetCredential(
@@ -228,7 +228,7 @@ Response WebAuthnHandler::GetCredential(
     std::unique_ptr<WebAuthn::Credential>* out_credential) {
   VirtualAuthenticator* authenticator;
   Response response = FindAuthenticator(authenticator_id, &authenticator);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   auto registration =
@@ -237,7 +237,7 @@ Response WebAuthnHandler::GetCredential(
     return Response::InvalidParams(kCredentialNotFound);
 
   *out_credential = BuildCredentialFromRegistration(*registration);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::GetCredentials(
@@ -245,7 +245,7 @@ Response WebAuthnHandler::GetCredentials(
     std::unique_ptr<Array<WebAuthn::Credential>>* out_credentials) {
   VirtualAuthenticator* authenticator;
   Response response = FindAuthenticator(authenticator_id, &authenticator);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   *out_credentials = std::make_unique<Array<WebAuthn::Credential>>();
@@ -253,41 +253,41 @@ Response WebAuthnHandler::GetCredentials(
     (*out_credentials)
         ->emplace_back(BuildCredentialFromRegistration(registration));
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::RemoveCredential(const String& authenticator_id,
                                            const Binary& credential_id) {
   VirtualAuthenticator* authenticator;
   Response response = FindAuthenticator(authenticator_id, &authenticator);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   if (!authenticator->RemoveRegistration(CopyBinaryToVector(credential_id)))
     return Response::InvalidParams(kCredentialNotFound);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::ClearCredentials(const String& authenticator_id) {
   VirtualAuthenticator* authenticator;
   Response response = FindAuthenticator(authenticator_id, &authenticator);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   authenticator->ClearRegistrations();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::SetUserVerified(const String& authenticator_id,
                                           bool is_user_verified) {
   VirtualAuthenticator* authenticator;
   Response response = FindAuthenticator(authenticator_id, &authenticator);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   authenticator->set_user_verified(is_user_verified);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response WebAuthnHandler::FindAuthenticator(
@@ -295,13 +295,13 @@ Response WebAuthnHandler::FindAuthenticator(
     VirtualAuthenticator** out_authenticator) {
   *out_authenticator = nullptr;
   if (!virtual_discovery_factory_)
-    return Response::Error(kVirtualEnvironmentNotEnabled);
+    return Response::ServerError(kVirtualEnvironmentNotEnabled);
 
   *out_authenticator = virtual_discovery_factory_->GetAuthenticator(id);
   if (!*out_authenticator)
     return Response::InvalidParams(kAuthenticatorNotFound);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace protocol

content/browser/devtools/protocol/webauthn_handler_unittest.cc

@@ -25,14 +25,13 @@ class WebAuthnHandlerTest : public testing::Test {
 
 TEST_F(WebAuthnHandlerTest, EnableFailsGracefullyIfNoFrameHostSet) {
   Response response = webauthn_handler()->Enable();
-  EXPECT_EQ(DispatchResponse::Status::kError, response.status());
-  EXPECT_STREQ("The DevTools session is not attached to a frame",
-               response.errorMessage().c_str());
+  EXPECT_EQ(crdtp::DispatchCode::SERVER_ERROR, response.Code());
+  EXPECT_EQ("The DevTools session is not attached to a frame",
+            response.Message());
 }
 
 TEST_F(WebAuthnHandlerTest, DisableGracefullyIfNoFrameHostSet) {
-  Response response = webauthn_handler()->Disable();
-  EXPECT_EQ(DispatchResponse::Status::kSuccess, response.status());
+  EXPECT_TRUE(webauthn_handler()->Disable().IsSuccess());
 }
 
 }  // namespace protocol

content/public/browser/devtools_agent_host.h

@@ -134,8 +134,7 @@ class CONTENT_EXPORT DevToolsAgentHost
   virtual bool IsAttached() = 0;
 
   // Sends |message| from |client| to the agent.
-  // Returns true if the message is dispatched and handled.
-  virtual bool DispatchProtocolMessage(DevToolsAgentHostClient* client,
+  virtual void DispatchProtocolMessage(DevToolsAgentHostClient* client,
                                        base::span<const uint8_t> message) = 0;
 
   // Starts inspecting element at position (|x|, |y|) in the frame

content/public/browser/devtools_manager_delegate.cc

@@ -61,7 +61,6 @@ void DevToolsManagerDelegate::ClientDetached(
 
 void DevToolsManagerDelegate::HandleCommand(
     DevToolsAgentHostClientChannel* channel,
-    const std::string& method,
     base::span<const uint8_t> message,
     NotHandledCallback callback) {
   std::move(callback).Run(message);

content/public/browser/devtools_manager_delegate.h

@@ -69,7 +69,6 @@ class CONTENT_EXPORT DevToolsManagerDelegate {
   using NotHandledCallback =
       base::OnceCallback<void(base::span<const uint8_t>)>;
   virtual void HandleCommand(DevToolsAgentHostClientChannel* channel,
-                             const std::string& method,
                              base::span<const uint8_t> message,
                              NotHandledCallback callback);
 

headless/lib/browser/headless_devtools_manager_delegate.cc

@@ -25,12 +25,11 @@ HeadlessDevToolsManagerDelegate::~HeadlessDevToolsManagerDelegate() = default;
 
 void HeadlessDevToolsManagerDelegate::HandleCommand(
     content::DevToolsAgentHostClientChannel* channel,
-    const std::string& method,
     base::span<const uint8_t> message,
     NotHandledCallback callback) {
   auto it = sessions_.find(channel);
   DCHECK(it != sessions_.end());
-  it->second->HandleCommand(method, message, std::move(callback));
+  it->second->HandleCommand(message, std::move(callback));
 }
 
 scoped_refptr<content::DevToolsAgentHost>

headless/lib/browser/headless_devtools_manager_delegate.h

@@ -30,7 +30,6 @@ class HeadlessDevToolsManagerDelegate
 
   // DevToolsManagerDelegate implementation:
   void HandleCommand(content::DevToolsAgentHostClientChannel* channel,
-                     const std::string& method,
                      base::span<const uint8_t> message,
                      NotHandledCallback callback) override;
   scoped_refptr<content::DevToolsAgentHost> CreateNewTarget(

headless/lib/browser/protocol/browser_handler.cc

@@ -42,7 +42,7 @@ void BrowserHandler::Wire(UberDispatcher* dispatcher) {
 }
 
 Response BrowserHandler::Disable() {
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::GetWindowForTarget(
@@ -53,12 +53,12 @@ Response BrowserHandler::GetWindowForTarget(
       browser_->GetWebContentsForDevToolsAgentHostId(
           target_id.fromMaybe(target_id_)));
   if (!web_contents)
-    return Response::Error("No web contents for the given target id");
+    return Response::ServerError("No web contents for the given target id");
 
   auto result = std::make_unique<base::DictionaryValue>();
   *out_window_id = web_contents->window_id();
   *out_bounds = CreateBrowserBounds(web_contents);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::GetWindowBounds(
@@ -67,16 +67,16 @@ Response BrowserHandler::GetWindowBounds(
   HeadlessWebContentsImpl* web_contents =
       browser_->GetWebContentsForWindowId(window_id);
   if (!web_contents)
-    return Response::Error("Browser window not found");
+    return Response::ServerError("Browser window not found");
   *out_bounds = CreateBrowserBounds(web_contents);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::Close() {
   base::PostTask(
       FROM_HERE, {content::BrowserThread::UI},
       base::BindOnce(&HeadlessBrowserImpl::Shutdown, browser_->GetWeakPtr()));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response BrowserHandler::SetWindowBounds(
@@ -85,7 +85,7 @@ Response BrowserHandler::SetWindowBounds(
   HeadlessWebContentsImpl* web_contents =
       browser_->GetWebContentsForWindowId(window_id);
   if (!web_contents)
-    return Response::Error("Browser window not found");
+    return Response::ServerError("Browser window not found");
 
   gfx::Rect bounds = web_contents->web_contents()->GetContainerBounds();
   const bool set_bounds = window_bounds->HasLeft() || window_bounds->HasTop() ||
@@ -100,25 +100,25 @@ Response BrowserHandler::SetWindowBounds(
 
   const std::string window_state = window_bounds->GetWindowState("normal");
   if (set_bounds && window_state != "normal") {
-    return Response::Error(
+    return Response::ServerError(
         "The 'minimized', 'maximized' and 'fullscreen' states cannot be "
         "combined with 'left', 'top', 'width' or 'height'");
   }
 
   if (set_bounds && web_contents->window_state() != "normal") {
-    return Response::Error(
+    return Response::ServerError(
         "To resize minimized/maximized/fullscreen window, restore it to normal "
         "state first.");
   }
 
   web_contents->set_window_state(window_state);
   web_contents->SetBounds(bounds);
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response BrowserHandler::SetDockTile(Maybe<std::string> label,
                                                Maybe<protocol::Binary> image) {
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace protocol

headless/lib/browser/protocol/headless_devtools_session.cc

@@ -13,6 +13,7 @@
 #include "headless/lib/browser/protocol/page_handler.h"
 #include "headless/lib/browser/protocol/target_handler.h"
 #include "third_party/inspector_protocol/crdtp/cbor.h"
+#include "third_party/inspector_protocol/crdtp/dispatch.h"
 #include "third_party/inspector_protocol/crdtp/json.h"
 
 namespace headless {
@@ -42,23 +43,24 @@ HeadlessDevToolsSession::~HeadlessDevToolsSession() {
 }
 
 void HeadlessDevToolsSession::HandleCommand(
-    const std::string& method,
     base::span<const uint8_t> message,
     content::DevToolsManagerDelegate::NotHandledCallback callback) {
-  if (!browser_ || !dispatcher_.canDispatch(method)) {
+  if (!browser_) {
     std::move(callback).Run(message);
     return;
   }
-  int call_id;
-  std::string unused;
-  std::unique_ptr<protocol::DictionaryValue> value =
-      protocol::DictionaryValue::cast(Value::parseBinary(
-          reinterpret_cast<const uint8_t*>(message.data()), message.size()));
-  if (!dispatcher_.parseCommand(value.get(), &call_id, &unused))
+  crdtp::Dispatchable dispatchable(crdtp::SpanFrom(message));
+  // content::DevToolsSession receives this message first, so we may
+  // assume it's ok.
+  DCHECK(dispatchable.ok());
+  crdtp::UberDispatcher::DispatchResult dispatched =
+      dispatcher_.Dispatch(dispatchable);
+  if (!dispatched.MethodFound()) {
+    std::move(callback).Run(message);
     return;
-  pending_commands_[call_id] = std::move(callback);
-  dispatcher_.dispatch(call_id, method, std::move(value),
-                       crdtp::SpanFrom(message));
+  }
+  pending_commands_[dispatchable.CallId()] = std::move(callback);
+  dispatched.Run();
 }
 
 void HeadlessDevToolsSession::AddHandler(
@@ -70,7 +72,7 @@ void HeadlessDevToolsSession::AddHandler(
 // The following methods handle responses or notifications coming from
 // the browser to the client.
 
-void HeadlessDevToolsSession::sendProtocolResponse(
+void HeadlessDevToolsSession::SendProtocolResponse(
     int call_id,
     std::unique_ptr<Serializable> message) {
   pending_commands_.erase(call_id);
@@ -78,15 +80,15 @@ void HeadlessDevToolsSession::sendProtocolResponse(
   client_channel_->DispatchProtocolMessageToClient(message->Serialize());
 }
 
-void HeadlessDevToolsSession::sendProtocolNotification(
+void HeadlessDevToolsSession::SendProtocolNotification(
     std::unique_ptr<Serializable> message) {
   client_channel_->DispatchProtocolMessageToClient(message->Serialize());
 }
 
-void HeadlessDevToolsSession::flushProtocolNotifications() {}
+void HeadlessDevToolsSession::FlushProtocolNotifications() {}
 
-void HeadlessDevToolsSession::fallThrough(int call_id,
-                                          const std::string& method,
+void HeadlessDevToolsSession::FallThrough(int call_id,
+                                          crdtp::span<uint8_t> method,
                                           crdtp::span<uint8_t> message) {
   auto callback = std::move(pending_commands_[call_id]);
   pending_commands_.erase(call_id);

headless/lib/browser/protocol/headless_devtools_session.h

@@ -29,7 +29,6 @@ class HeadlessDevToolsSession : public FrontendChannel {
   ~HeadlessDevToolsSession() override;
 
   void HandleCommand(
-      const std::string& method,
       base::span<const uint8_t> message,
       content::DevToolsManagerDelegate::NotHandledCallback callback);
 
@@ -37,12 +36,12 @@ class HeadlessDevToolsSession : public FrontendChannel {
   void AddHandler(std::unique_ptr<DomainHandler> handler);
 
   // FrontendChannel:
-  void sendProtocolResponse(int call_id,
+  void SendProtocolResponse(int call_id,
                             std::unique_ptr<Serializable> message) override;
-  void sendProtocolNotification(std::unique_ptr<Serializable> message) override;
-  void flushProtocolNotifications() override;
-  void fallThrough(int call_id,
-                   const std::string& method,
+  void SendProtocolNotification(std::unique_ptr<Serializable> message) override;
+  void FlushProtocolNotifications() override;
+  void FallThrough(int call_id,
+                   crdtp::span<uint8_t> method,
                    crdtp::span<uint8_t> message) override;
 
   base::WeakPtr<HeadlessBrowserImpl> browser_;

headless/lib/browser/protocol/headless_handler.cc

@@ -58,7 +58,7 @@ void OnBeginFrameFinished(
     std::unique_ptr<SkBitmap> bitmap,
     std::string error_message) {
   if (!error_message.empty()) {
-    callback->sendFailure(Response::Error(std::move(error_message)));
+    callback->sendFailure(Response::ServerError(std::move(error_message)));
     return;
   }
   if (!bitmap || bitmap->drawsNothing()) {
@@ -84,11 +84,11 @@ void HeadlessHandler::Wire(UberDispatcher* dispatcher) {
 Response HeadlessHandler::Enable() {
   if (frontend_)
     frontend_->NeedsBeginFramesChanged(true);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response HeadlessHandler::Disable() {
-  return Response::OK();
+  return Response::Success();
 }
 
 void HeadlessHandler::BeginFrame(Maybe<double> in_frame_time_ticks,
@@ -99,7 +99,7 @@ void HeadlessHandler::BeginFrame(Maybe<double> in_frame_time_ticks,
   HeadlessWebContentsImpl* headless_contents =
       HeadlessWebContentsImpl::From(browser_, web_contents_);
   if (!headless_contents->begin_frame_control_enabled()) {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         "Command is only supported if BeginFrameControl is enabled."));
     return;
   }
@@ -107,9 +107,9 @@ void HeadlessHandler::BeginFrame(Maybe<double> in_frame_time_ticks,
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           ::switches::kRunAllCompositorStagesBeforeDraw)) {
     callback->sendFailure(
-        Response::Error("Command is only supported with "
-                        "--run-all-compositor-stages-before-draw, see "
-                        "https://goo.gl/3zHXhB for more info."));
+        Response::ServerError("Command is only supported with "
+                              "--run-all-compositor-stages-before-draw, see "
+                              "https://goo.gl/3zHXhB for more info."));
     return;
   }
 

headless/lib/browser/protocol/page_handler.cc

@@ -37,7 +37,7 @@ void PageHandler::Wire(UberDispatcher* dispatcher) {
 }
 
 Response PageHandler::Disable() {
-  return Response::OK();
+  return Response::Success();
 }
 
 void PageHandler::PrintToPDF(Maybe<bool> landscape,
@@ -138,7 +138,7 @@ void PageHandler::PrintToPDF(Maybe<bool> landscape,
           base::BindOnce(&PageHandler::PDFCreated, weak_factory_.GetWeakPtr(),
                          return_as_stream, std::move(callback)));
 #else
-  callback->sendFailure(Response::Error("Printing is not enabled"));
+  callback->sendFailure(Response::ServerError("Printing is not enabled"));
   return;
 #endif  // BUILDFLAG(ENABLE_PRINTING)
 }
@@ -151,7 +151,7 @@ void PageHandler::PDFCreated(
     scoped_refptr<base::RefCountedMemory> data) {
   std::unique_ptr<base::DictionaryValue> response;
   if (print_result != HeadlessPrintManager::PRINT_SUCCESS) {
-    callback->sendFailure(Response::Error(
+    callback->sendFailure(Response::ServerError(
         HeadlessPrintManager::PrintResultToString(print_result)));
     return;
   }

headless/lib/browser/protocol/target_handler.cc

@@ -23,7 +23,7 @@ void TargetHandler::Wire(UberDispatcher* dispatcher) {
 }
 
 Response TargetHandler::Disable() {
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::CreateTarget(const std::string& url,
@@ -35,8 +35,10 @@ Response TargetHandler::CreateTarget(const std::string& url,
                                      Maybe<bool> background,
                                      std::string* out_target_id) {
 #if defined(OS_MACOSX)
-  if (enable_begin_frame_control.fromMaybe(false))
-    return Response::Error("BeginFrameControl is not supported on MacOS yet");
+  if (enable_begin_frame_control.fromMaybe(false)) {
+    return Response::ServerError(
+        "BeginFrameControl is not supported on MacOS yet");
+  }
 #endif
 
   HeadlessBrowserContext* context;
@@ -47,7 +49,7 @@ Response TargetHandler::CreateTarget(const std::string& url,
   } else {
     context = browser_->GetDefaultBrowserContext();
     if (!context) {
-      return Response::Error(
+      return Response::ServerError(
           "You specified no |browserContextId|, but "
           "there is no default browser context set on "
           "HeadlessBrowser");
@@ -65,7 +67,7 @@ Response TargetHandler::CreateTarget(const std::string& url,
           .Build());
 
   *out_target_id = web_contents_impl->GetDevToolsAgentHostId();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response TargetHandler::CloseTarget(const std::string& target_id,
@@ -77,7 +79,7 @@ Response TargetHandler::CloseTarget(const std::string& target_id,
     web_contents->Close();
     *out_success = true;
   }
-  return Response::OK();
+  return Response::Success();
 }
 }  // namespace protocol
 }  // namespace headless

third_party/blink/renderer/core/inspector/devtools_session.cc

@@ -25,6 +25,7 @@
 #include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
 #include "third_party/blink/renderer/platform/wtf/text/string_utf8_adaptor.h"
 #include "third_party/inspector_protocol/crdtp/cbor.h"
+#include "third_party/inspector_protocol/crdtp/dispatch.h"
 #include "third_party/inspector_protocol/crdtp/json.h"
 
 namespace blink {
@@ -182,10 +183,6 @@ void DevToolsSession::Detach() {
   agent_->client_->DebuggerTaskFinished();
 }
 
-void DevToolsSession::FlushProtocolNotifications() {
-  flushProtocolNotifications();
-}
-
 void DevToolsSession::DispatchProtocolCommand(
     int call_id,
     const String& method,
@@ -202,7 +199,6 @@ void DevToolsSession::DispatchProtocolCommandImpl(
     base::span<const uint8_t> data) {
   DCHECK(crdtp::cbor::IsCBORMessage(
       crdtp::span<uint8_t>(data.data(), data.size())));
-
   TRACE_EVENT_WITH_FLOW1(
       "devtools", "DevToolsSession::DispatchProtocolCommandImpl", call_id,
       TRACE_EVENT_FLAG_FLOW_OUT | TRACE_EVENT_FLAG_FLOW_IN, "call_id", call_id);
@@ -226,11 +222,10 @@ void DevToolsSession::DispatchProtocolCommandImpl(
     v8_session_->dispatchProtocolMessage(
         v8_inspector::StringView(data.data(), data.size()));
   } else {
-    std::unique_ptr<protocol::Value> value =
-        protocol::Value::parseBinary(data.data(), data.size());
-    // Don't pass protocol message further - there is no passthrough.
-    inspector_backend_dispatcher_->dispatch(call_id, method, std::move(value),
-                                            crdtp::span<uint8_t>());
+    crdtp::Dispatchable dispatchable(crdtp::SpanFrom(data));
+    // This message has already been checked by content::DevToolsSession.
+    DCHECK(dispatchable.ok());
+    inspector_backend_dispatcher_->Dispatch(dispatchable).Run();
   }
   agent_->client_->DebuggerTaskFinished();
 }
@@ -271,14 +266,14 @@ void DevToolsSession::DomContentLoadedEventFired(LocalFrame* local_frame) {
   }
 }
 
-void DevToolsSession::sendProtocolResponse(
+void DevToolsSession::SendProtocolResponse(
     int call_id,
     std::unique_ptr<protocol::Serializable> message) {
   SendProtocolResponse(call_id, message->Serialize());
 }
 
-void DevToolsSession::fallThrough(int call_id,
-                                  const String& method,
+void DevToolsSession::FallThrough(int call_id,
+                                  crdtp::span<uint8_t> method,
                                   crdtp::span<uint8_t> message) {
   // There's no other layer to handle the command.
   NOTREACHED();
@@ -309,7 +304,7 @@ void DevToolsSession::SendProtocolResponse(int call_id,
                                          call_id, session_state_.TakeUpdates());
 }
 
-void DevToolsSession::sendProtocolNotification(
+void DevToolsSession::SendProtocolNotification(
     std::unique_ptr<protocol::Serializable> notification) {
   if (IsDetached())
     return;
@@ -332,6 +327,10 @@ void DevToolsSession::sendNotification(
 }
 
 void DevToolsSession::flushProtocolNotifications() {
+  FlushProtocolNotifications();
+}
+
+void DevToolsSession::FlushProtocolNotifications() {
   if (IsDetached())
     return;
   for (wtf_size_t i = 0; i < agents_.size(); i++)

third_party/blink/renderer/core/inspector/devtools_session.h

@@ -53,9 +53,11 @@ class CORE_EXPORT DevToolsSession : public GarbageCollected<DevToolsSession>,
 
   void Append(InspectorAgent*);
   void Detach();
-  void FlushProtocolNotifications();
   void Trace(Visitor*);
 
+  // protocol::FrontendChannel implementation.
+  void FlushProtocolNotifications() override;
+
   // Core probes.
   void DidStartProvisionalLoad(LocalFrame*);
   void DidFailProvisionalLoad(LocalFrame*);
@@ -75,15 +77,14 @@ class CORE_EXPORT DevToolsSession : public GarbageCollected<DevToolsSession>,
                                    base::span<const uint8_t> message);
 
   // protocol::FrontendChannel implementation.
-  void sendProtocolResponse(
+  void SendProtocolResponse(
       int call_id,
       std::unique_ptr<protocol::Serializable> message) override;
-  void sendProtocolNotification(
+  void SendProtocolNotification(
       std::unique_ptr<protocol::Serializable> message) override;
-  void fallThrough(int call_id,
-                   const String& method,
+  void FallThrough(int call_id,
+                   crdtp::span<uint8_t> method,
                    crdtp::span<uint8_t> message) override;
-  void flushProtocolNotifications() override;
 
   // v8_inspector::V8Inspector::Channel implementation.
   void sendResponse(
@@ -91,6 +92,7 @@ class CORE_EXPORT DevToolsSession : public GarbageCollected<DevToolsSession>,
       std::unique_ptr<v8_inspector::StringBuffer> message) override;
   void sendNotification(
       std::unique_ptr<v8_inspector::StringBuffer> message) override;
+  void flushProtocolNotifications() override;
 
   bool IsDetached();
   void SendProtocolResponse(int call_id, std::vector<uint8_t> message);

third_party/blink/renderer/core/inspector/dom_editor.cc

@@ -457,9 +457,10 @@ static Response ToResponse(ExceptionState& exception_state) {
                                    exception_state.CodeAs<DOMExceptionCode>()) +
                                    " "
                              : g_empty_string;
-    return Response::Error(name_prefix + exception_state.Message());
+    String msg = name_prefix + exception_state.Message();
+    return Response::ServerError(msg.Utf8());
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response DOMEditor::InsertBefore(ContainerNode* parent_node,

third_party/blink/renderer/core/inspector/inspector_animation_agent.cc

@@ -75,7 +75,7 @@ void InspectorAnimationAgent::Restore() {
 Response InspectorAnimationAgent::enable() {
   enabled_.Set(true);
   instrumenting_agents_->AddInspectorAnimationAgent(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAnimationAgent::disable() {
@@ -87,7 +87,7 @@ Response InspectorAnimationAgent::disable() {
   id_to_animation_.clear();
   id_to_animation_clone_.clear();
   cleared_animations_.clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorAnimationAgent::DidCommitLoadForLocalFrame(LocalFrame* frame) {
@@ -205,21 +205,21 @@ InspectorAnimationAgent::BuildObjectForAnimation(blink::Animation& animation) {
 
 Response InspectorAnimationAgent::getPlaybackRate(double* playback_rate) {
   *playback_rate = ReferenceTimeline().PlaybackRate();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAnimationAgent::setPlaybackRate(double playback_rate) {
   for (LocalFrame* frame : *inspected_frames_)
     frame->GetDocument()->Timeline().SetPlaybackRate(playback_rate);
   playback_rate_.Set(playback_rate);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAnimationAgent::getCurrentTime(const String& id,
                                                  double* current_time) {
   blink::Animation* animation = nullptr;
   Response response = AssertAnimation(id, animation);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (id_to_animation_clone_.at(id))
     animation = id_to_animation_clone_.at(id);
@@ -235,7 +235,7 @@ Response InspectorAnimationAgent::getCurrentTime(const String& id,
                               animation->startTime().value_or(NullValue())
                         : NullValue();
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAnimationAgent::setPaused(
@@ -244,11 +244,11 @@ Response InspectorAnimationAgent::setPaused(
   for (const String& animation_id : *animation_ids) {
     blink::Animation* animation = nullptr;
     Response response = AssertAnimation(animation_id, animation);
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
     blink::Animation* clone = AnimationClone(animation);
     if (!clone)
-      return Response::Error("Failed to clone detached animation");
+      return Response::ServerError("Failed to clone detached animation");
     if (paused && !clone->Paused()) {
       // Ensure we restore a current time if the animation is limited.
       double current_time = 0;
@@ -268,7 +268,7 @@ Response InspectorAnimationAgent::setPaused(
       clone->Unpause();
     }
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 blink::Animation* InspectorAnimationAgent::AnimationClone(
@@ -323,16 +323,16 @@ Response InspectorAnimationAgent::seekAnimations(
   for (const String& animation_id : *animation_ids) {
     blink::Animation* animation = nullptr;
     Response response = AssertAnimation(animation_id, animation);
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
     blink::Animation* clone = AnimationClone(animation);
     if (!clone)
-      return Response::Error("Failed to clone a detached animation.");
+      return Response::ServerError("Failed to clone a detached animation.");
     if (!clone->Paused())
       clone->play();
     clone->setCurrentTime(current_time, false);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAnimationAgent::releaseAnimations(
@@ -348,7 +348,7 @@ Response InspectorAnimationAgent::releaseAnimations(
     id_to_animation_.erase(animation_id);
     cleared_animations_.insert(animation_id);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAnimationAgent::setTiming(const String& animation_id,
@@ -356,7 +356,7 @@ Response InspectorAnimationAgent::setTiming(const String& animation_id,
                                             double delay) {
   blink::Animation* animation = nullptr;
   Response response = AssertAnimation(animation_id, animation);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   animation = AnimationClone(animation);
@@ -368,7 +368,7 @@ Response InspectorAnimationAgent::setTiming(const String& animation_id,
   timing->setDuration(unrestricted_duration);
   timing->setDelay(delay);
   animation->effect()->updateTiming(timing, exception_state);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAnimationAgent::resolveAnimation(
@@ -377,7 +377,7 @@ Response InspectorAnimationAgent::resolveAnimation(
         result) {
   blink::Animation* animation = nullptr;
   Response response = AssertAnimation(animation_id, animation);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (id_to_animation_clone_.at(animation_id))
     animation = id_to_animation_clone_.at(animation_id);
@@ -388,7 +388,7 @@ Response InspectorAnimationAgent::resolveAnimation(
   ScriptState* script_state =
       frame ? ToScriptStateForMainWorld(frame) : nullptr;
   if (!script_state)
-    return Response::Error("Element not associated with a document.");
+    return Response::ServerError("Element not associated with a document.");
 
   ScriptState::Scope scope(script_state);
   static const char kAnimationObjectGroup[] = "animation";
@@ -401,8 +401,8 @@ Response InspectorAnimationAgent::resolveAnimation(
       ToV8InspectorStringView(kAnimationObjectGroup),
       false /* generatePreview */);
   if (!*result)
-    return Response::Error("Element not associated with a document.");
-  return Response::OK();
+    return Response::ServerError("Element not associated with a document.");
+  return Response::Success();
 }
 
 String InspectorAnimationAgent::CreateCSSId(blink::Animation& animation) {
@@ -499,8 +499,8 @@ Response InspectorAnimationAgent::AssertAnimation(const String& id,
                                                   blink::Animation*& result) {
   result = id_to_animation_.at(id);
   if (!result)
-    return Response::Error("Could not find animation with given id");
-  return Response::OK();
+    return Response::ServerError("Could not find animation with given id");
+  return Response::Success();
 }
 
 DocumentTimeline& InspectorAnimationAgent::ReferenceTimeline() {

third_party/blink/renderer/core/inspector/inspector_application_cache_agent.cc

@@ -57,13 +57,13 @@ void InspectorApplicationCacheAgent::Restore() {
 Response InspectorApplicationCacheAgent::enable() {
   if (!enabled_.Get())
     InnerEnable();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorApplicationCacheAgent::disable() {
   enabled_.Clear();
   instrumenting_agents_->RemoveInspectorApplicationCacheAgent(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorApplicationCacheAgent::UpdateApplicationCacheStatus(
@@ -115,7 +115,7 @@ Response InspectorApplicationCacheAgent::getFramesWithManifests(
       (*result)->emplace_back(std::move(value));
     }
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorApplicationCacheAgent::AssertFrameWithDocumentLoader(
@@ -124,12 +124,12 @@ Response InspectorApplicationCacheAgent::AssertFrameWithDocumentLoader(
   LocalFrame* frame =
       IdentifiersFactory::FrameById(inspected_frames_, frame_id);
   if (!frame)
-    return Response::Error("No frame for given id found");
+    return Response::ServerError("No frame for given id found");
 
   result = frame->Loader().GetDocumentLoader();
   if (!result)
-    return Response::Error("No documentLoader for given frame found");
-  return Response::OK();
+    return Response::ServerError("No documentLoader for given frame found");
+  return Response::Success();
 }
 
 Response InspectorApplicationCacheAgent::getManifestForFrame(
@@ -137,13 +137,13 @@ Response InspectorApplicationCacheAgent::getManifestForFrame(
     String* manifest_url) {
   DocumentLoader* document_loader = nullptr;
   Response response = AssertFrameWithDocumentLoader(frame_id, document_loader);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   ApplicationCacheHost::CacheInfo info =
       document_loader->GetApplicationCacheHost()->ApplicationCacheInfo();
   *manifest_url = info.manifest_.GetString();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorApplicationCacheAgent::getApplicationCacheForFrame(
@@ -152,7 +152,7 @@ Response InspectorApplicationCacheAgent::getApplicationCacheForFrame(
         application_cache) {
   DocumentLoader* document_loader = nullptr;
   Response response = AssertFrameWithDocumentLoader(frame_id, document_loader);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   ApplicationCacheHostForFrame* host =
@@ -163,7 +163,7 @@ Response InspectorApplicationCacheAgent::getApplicationCacheForFrame(
   host->FillResourceList(&resources);
 
   *application_cache = BuildObjectForApplicationCache(resources, info);
-  return Response::OK();
+  return Response::Success();
 }
 
 std::unique_ptr<protocol::ApplicationCache::ApplicationCache>

third_party/blink/renderer/core/inspector/inspector_audits_agent.cc

@@ -106,20 +106,20 @@ protocol::Response InspectorAuditsAgent::getEncodedResponse(
   bool is_base64_encoded;
   Response response =
       network_agent_->GetResponseBody(request_id, &body, &is_base64_encoded);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Vector<char> base64_decoded_buffer;
   if (!is_base64_encoded || !Base64Decode(body, base64_decoded_buffer) ||
       base64_decoded_buffer.size() == 0) {
-    return Response::Error("Failed to decode original image");
+    return Response::ServerError("Failed to decode original image");
   }
 
   Vector<unsigned char> encoded_image;
   if (!EncodeAsImage(base64_decoded_buffer.data(), base64_decoded_buffer.size(),
                      encoding, quality.fromMaybe(kDefaultEncodeQuality),
                      &encoded_image)) {
-    return Response::Error("Could not encode image with given settings");
+    return Response::ServerError("Could not encode image with given settings");
   }
 
   *out_original_size = static_cast<int>(base64_decoded_buffer.size());
@@ -128,27 +128,27 @@ protocol::Response InspectorAuditsAgent::getEncodedResponse(
   if (!size_only.fromMaybe(false)) {
     *out_body = protocol::Binary::fromVector(std::move(encoded_image));
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAuditsAgent::enable() {
   if (enabled_.Get()) {
-    return Response::OK();
+    return Response::Success();
   }
 
   enabled_.Set(true);
   InnerEnable();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorAuditsAgent::disable() {
   if (!enabled_.Get()) {
-    return Response::OK();
+    return Response::Success();
   }
 
   enabled_.Clear();
   instrumenting_agents_->RemoveInspectorAuditsAgent(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorAuditsAgent::Restore() {

third_party/blink/renderer/core/inspector/inspector_base_agent.h

@@ -76,7 +76,9 @@ class InspectorBaseAgent : public InspectorAgent,
     agent_state_.InitFrom(session_state);
   }
 
-  protocol::Response disable() override { return protocol::Response::OK(); }
+  protocol::Response disable() override {
+    return protocol::Response::Success();
+  }
 
   void Dispose() override {
     disable();

third_party/blink/renderer/core/inspector/inspector_css_agent.cc

@@ -712,7 +712,7 @@ void InspectorCSSAgent::ResetNonPersistentData() {
 void InspectorCSSAgent::enable(std::unique_ptr<EnableCallback> prp_callback) {
   if (!dom_agent_->Enabled()) {
     prp_callback->sendFailure(
-        Response::Error("DOM agent needs to be enabled first."));
+        Response::ServerError("DOM agent needs to be enabled first."));
     return;
   }
   enable_requested_.Set(true);
@@ -747,7 +747,7 @@ Response InspectorCSSAgent::disable() {
   resource_content_loader_->Cancel(resource_content_loader_client_id_);
   coverage_enabled_.Set(false);
   SetCoverageEnabled(false);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorCSSAgent::DidCommitLoadForLocalFrame(LocalFrame* frame) {
@@ -908,7 +908,7 @@ Response InspectorCSSAgent::getMediaQueries(
         CollectMediaQueriesFromRule(rule, medias->get());
     }
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::getMatchedStylesForNode(
@@ -923,12 +923,12 @@ Response InspectorCSSAgent::getMatchedStylesForNode(
     Maybe<protocol::Array<protocol::CSS::CSSKeyframesRule>>*
         css_keyframes_rules) {
   Response response = AssertEnabled();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Element* element = nullptr;
   response = dom_agent_->AssertElement(node_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Element* original_element = element;
@@ -936,13 +936,13 @@ Response InspectorCSSAgent::getMatchedStylesForNode(
   if (element_pseudo_id) {
     element = element->ParentOrShadowHostElement();
     if (!element)
-      return Response::Error("Pseudo element has no parent");
+      return Response::ServerError("Pseudo element has no parent");
   }
 
   Document* owner_document = element->ownerDocument();
   // A non-active document has no styles.
   if (!owner_document->IsActive())
-    return Response::Error("Document is not active");
+    return Response::ServerError("Document is not active");
 
   // FIXME: It's really gross for the inspector to reach in and access
   // StyleResolver directly here. We need to provide the Inspector better APIs
@@ -959,7 +959,7 @@ Response InspectorCSSAgent::getMatchedStylesForNode(
 
   // Pseudo elements.
   if (element_pseudo_id)
-    return Response::OK();
+    return Response::Success();
 
   InspectorStyleSheetForInlineStyle* inline_style_sheet =
       AsInspectorStyleSheet(element);
@@ -1014,7 +1014,7 @@ Response InspectorCSSAgent::getMatchedStylesForNode(
   }
 
   *css_keyframes_rules = AnimationsForNode(element);
-  return Response::OK();
+  return Response::Success();
 }
 
 template <class CSSRuleCollection>
@@ -1101,21 +1101,21 @@ Response InspectorCSSAgent::getInlineStylesForNode(
     Maybe<protocol::CSS::CSSStyle>* inline_style,
     Maybe<protocol::CSS::CSSStyle>* attributes_style) {
   Response response = AssertEnabled();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   Element* element = nullptr;
   response = dom_agent_->AssertElement(node_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   InspectorStyleSheetForInlineStyle* style_sheet =
       AsInspectorStyleSheet(element);
   if (!style_sheet)
-    return Response::Error("Element is not a style sheet");
+    return Response::ServerError("Element is not a style sheet");
 
   *inline_style = style_sheet->BuildObjectForStyle(element->style());
   *attributes_style = BuildObjectForAttributesStyle(element);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::getComputedStyleForNode(
@@ -1123,11 +1123,11 @@ Response InspectorCSSAgent::getComputedStyleForNode(
     std::unique_ptr<protocol::Array<protocol::CSS::CSSComputedStyleProperty>>*
         style) {
   Response response = AssertEnabled();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   Node* node = nullptr;
   response = dom_agent_->AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   auto* computed_style_info =
@@ -1154,7 +1154,7 @@ Response InspectorCSSAgent::getComputedStyleForNode(
                                .setValue(it.value->CssText())
                                .build());
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorCSSAgent::CollectPlatformFontsForLayoutObject(
@@ -1219,11 +1219,11 @@ Response InspectorCSSAgent::getPlatformFontsForNode(
     std::unique_ptr<protocol::Array<protocol::CSS::PlatformFontUsage>>*
         platform_fonts) {
   Response response = AssertEnabled();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   Node* node = nullptr;
   response = dom_agent_->AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   HashCountedSet<std::pair<int, String>> font_stats;
@@ -1246,7 +1246,7 @@ Response InspectorCSSAgent::getPlatformFontsForNode(
                            .setGlyphCount(font.value)
                            .build());
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::getStyleSheetText(const String& style_sheet_id,
@@ -1254,11 +1254,11 @@ Response InspectorCSSAgent::getStyleSheetText(const String& style_sheet_id,
   InspectorStyleSheetBase* inspector_style_sheet = nullptr;
   Response response =
       AssertStyleSheetForId(style_sheet_id, inspector_style_sheet);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   inspector_style_sheet->GetText(result);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::collectClassNames(
@@ -1267,10 +1267,10 @@ Response InspectorCSSAgent::collectClassNames(
   InspectorStyleSheet* inspector_style_sheet = nullptr;
   Response response =
       AssertInspectorStyleSheetForId(style_sheet_id, inspector_style_sheet);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   *class_names = inspector_style_sheet->CollectClassNames();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::setStyleSheetText(
@@ -1281,7 +1281,7 @@ Response InspectorCSSAgent::setStyleSheetText(
   InspectorStyleSheetBase* inspector_style_sheet = nullptr;
   Response response =
       AssertStyleSheetForId(style_sheet_id, inspector_style_sheet);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -1289,25 +1289,33 @@ Response InspectorCSSAgent::setStyleSheetText(
                                      inspector_style_sheet, text),
                                  exception_state);
   response = InspectorDOMAgent::ToResponse(exception_state);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (!inspector_style_sheet->SourceMapURL().IsEmpty())
     *source_map_url = inspector_style_sheet->SourceMapURL();
-  return Response::OK();
+  return Response::Success();
 }
 
 static Response JsonRangeToSourceRange(
     InspectorStyleSheetBase* inspector_style_sheet,
     protocol::CSS::SourceRange* range,
     SourceRange* source_range) {
-  if (range->getStartLine() < 0)
-    return Response::Error("range.startLine must be a non-negative integer");
-  if (range->getStartColumn() < 0)
-    return Response::Error("range.startColumn must be a non-negative integer");
-  if (range->getEndLine() < 0)
-    return Response::Error("range.endLine must be a non-negative integer");
-  if (range->getEndColumn() < 0)
-    return Response::Error("range.endColumn must be a non-negative integer");
+  if (range->getStartLine() < 0) {
+    return Response::ServerError(
+        "range.startLine must be a non-negative integer");
+  }
+  if (range->getStartColumn() < 0) {
+    return Response::ServerError(
+        "range.startColumn must be a non-negative integer");
+  }
+  if (range->getEndLine() < 0) {
+    return Response::ServerError(
+        "range.endLine must be a non-negative integer");
+  }
+  if (range->getEndColumn() < 0) {
+    return Response::ServerError(
+        "range.endColumn must be a non-negative integer");
+  }
 
   unsigned start_offset = 0;
   unsigned end_offset = 0;
@@ -1317,13 +1325,13 @@ static Response JsonRangeToSourceRange(
       inspector_style_sheet->LineNumberAndColumnToOffset(
           range->getEndLine(), range->getEndColumn(), &end_offset);
   if (!success)
-    return Response::Error("Specified range is out of bounds");
+    return Response::ServerError("Specified range is out of bounds");
 
   if (start_offset > end_offset)
-    return Response::Error("Range start must not succeed its end");
+    return Response::ServerError("Range start must not succeed its end");
   source_range->start = start_offset;
   source_range->end = end_offset;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::setRuleSelector(
@@ -1335,12 +1343,12 @@ Response InspectorCSSAgent::setRuleSelector(
   InspectorStyleSheet* inspector_style_sheet = nullptr;
   Response response =
       AssertInspectorStyleSheetForId(style_sheet_id, inspector_style_sheet);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   SourceRange selector_range;
   response = JsonRangeToSourceRange(inspector_style_sheet, range.get(),
                                     &selector_range);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -1352,8 +1360,10 @@ Response InspectorCSSAgent::setRuleSelector(
     CSSStyleRule* rule = InspectorCSSAgent::AsCSSStyleRule(action->TakeRule());
     InspectorStyleSheet* inspector_style_sheet =
         InspectorStyleSheetForRule(rule);
-    if (!inspector_style_sheet)
-      return Response::Error("Failed to get inspector style sheet for rule.");
+    if (!inspector_style_sheet) {
+      return Response::ServerError(
+          "Failed to get inspector style sheet for rule.");
+    }
     *result = inspector_style_sheet->BuildObjectForSelectorList(rule);
   }
   return InspectorDOMAgent::ToResponse(exception_state);
@@ -1368,12 +1378,12 @@ Response InspectorCSSAgent::setKeyframeKey(
   InspectorStyleSheet* inspector_style_sheet = nullptr;
   Response response =
       AssertInspectorStyleSheetForId(style_sheet_id, inspector_style_sheet);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   SourceRange key_range;
   response =
       JsonRangeToSourceRange(inspector_style_sheet, range.get(), &key_range);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -1385,9 +1395,10 @@ Response InspectorCSSAgent::setKeyframeKey(
     auto* rule = To<CSSKeyframeRule>(action->TakeRule());
     InspectorStyleSheet* inspector_style_sheet =
         BindStyleSheet(rule->parentStyleSheet());
-    if (!inspector_style_sheet)
-      return Response::Error("Failed to get inspector style sheet for rule.");
-
+    if (!inspector_style_sheet) {
+      return Response::ServerError(
+          "Failed to get inspector style sheet for rule.");
+    }
     CSSRuleSourceData* source_data =
         inspector_style_sheet->SourceDataForRule(rule);
     *result = protocol::CSS::Value::create()
@@ -1404,22 +1415,23 @@ Response InspectorCSSAgent::MultipleStyleTextsActions(
     HeapVector<Member<StyleSheetAction>>* actions) {
   size_t n = edits->size();
   if (n == 0)
-    return Response::Error("Edits should not be empty");
+    return Response::ServerError("Edits should not be empty");
 
   for (size_t i = 0; i < n; ++i) {
     protocol::CSS::StyleDeclarationEdit* edit = (*edits)[i].get();
     InspectorStyleSheetBase* inspector_style_sheet = nullptr;
     Response response =
         AssertStyleSheetForId(edit->getStyleSheetId(), inspector_style_sheet);
-    if (!response.isSuccess()) {
-      return Response::Error(String::Format(
-          "StyleSheet not found for edit #%zu of %zu", i + 1, n));
+    if (!response.IsSuccess()) {
+      return Response::ServerError(
+          String::Format("StyleSheet not found for edit #%zu of %zu", i + 1, n)
+              .Utf8());
     }
 
     SourceRange range;
     response =
         JsonRangeToSourceRange(inspector_style_sheet, edit->getRange(), &range);
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
 
     if (inspector_style_sheet->IsInlineStyle()) {
@@ -1438,7 +1450,7 @@ Response InspectorCSSAgent::MultipleStyleTextsActions(
       actions->push_back(action);
     }
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::setStyleTexts(
@@ -1447,7 +1459,7 @@ Response InspectorCSSAgent::setStyleTexts(
   FrontendOperationScope scope;
   HeapVector<Member<StyleSheetAction>> actions;
   Response response = MultipleStyleTextsActions(std::move(edits), &actions);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -1465,9 +1477,9 @@ Response InspectorCSSAgent::setStyleTexts(
         revert->Undo(undo_exception_state);
         DCHECK(!undo_exception_state.HadException());
       }
-      return Response::Error(
-          String::Format("Failed applying edit #%d: ", i) +
-          InspectorDOMAgent::ToResponse(exception_state).errorMessage());
+      return Response::ServerError(
+          String::Format("Failed applying edit #%d: ", i).Utf8() +
+          InspectorDOMAgent::ToResponse(exception_state).Message());
     }
     serialized_styles->emplace_back(action->TakeSerializedStyle());
   }
@@ -1477,7 +1489,7 @@ Response InspectorCSSAgent::setStyleTexts(
     dom_agent_->History()->AppendPerformedAction(action);
   }
   *result = std::move(serialized_styles);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::SetStyleText(
@@ -1494,7 +1506,7 @@ Response InspectorCSSAgent::SetStyleText(
     bool success = dom_agent_->History()->Perform(action, exception_state);
     if (success) {
       result = inline_style_sheet->InlineStyle();
-      return Response::OK();
+      return Response::Success();
     }
   } else {
     ModifyRuleAction* action = MakeGarbageCollected<ModifyRuleAction>(
@@ -1505,11 +1517,11 @@ Response InspectorCSSAgent::SetStyleText(
       CSSRule* rule = action->TakeRule();
       if (auto* style_rule = DynamicTo<CSSStyleRule>(rule)) {
         result = style_rule->style();
-        return Response::OK();
+        return Response::Success();
       }
       if (auto* keyframe_rule = DynamicTo<CSSKeyframeRule>(rule)) {
         result = keyframe_rule->style();
-        return Response::OK();
+        return Response::Success();
       }
     }
   }
@@ -1525,12 +1537,12 @@ Response InspectorCSSAgent::setMediaText(
   InspectorStyleSheet* inspector_style_sheet = nullptr;
   Response response =
       AssertInspectorStyleSheetForId(style_sheet_id, inspector_style_sheet);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   SourceRange text_range;
   response =
       JsonRangeToSourceRange(inspector_style_sheet, range.get(), &text_range);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -1556,20 +1568,20 @@ Response InspectorCSSAgent::createStyleSheet(
   LocalFrame* frame =
       IdentifiersFactory::FrameById(inspected_frames_, frame_id);
   if (!frame)
-    return Response::Error("Frame not found");
+    return Response::ServerError("Frame not found");
 
   Document* document = frame->GetDocument();
   if (!document)
-    return Response::Error("Frame does not have a document");
+    return Response::ServerError("Frame does not have a document");
 
   InspectorStyleSheet* inspector_style_sheet = ViaInspectorStyleSheet(document);
   if (!inspector_style_sheet)
-    return Response::Error("No target stylesheet found");
+    return Response::ServerError("No target stylesheet found");
 
   UpdateActiveStyleSheets(document);
 
   *out_style_sheet_id = inspector_style_sheet->Id();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::addRule(
@@ -1581,12 +1593,12 @@ Response InspectorCSSAgent::addRule(
   InspectorStyleSheet* inspector_style_sheet = nullptr;
   Response response =
       AssertInspectorStyleSheetForId(style_sheet_id, inspector_style_sheet);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   SourceRange rule_location;
   response = JsonRangeToSourceRange(inspector_style_sheet, location.get(),
                                     &rule_location);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -1598,18 +1610,18 @@ Response InspectorCSSAgent::addRule(
 
   CSSStyleRule* rule = action->TakeRule();
   *result = BuildObjectForRule(rule);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::forcePseudoState(
     int node_id,
     std::unique_ptr<protocol::Array<String>> forced_pseudo_classes) {
   Response response = AssertEnabled();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   Element* element = nullptr;
   response = dom_agent_->AssertElement(node_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   unsigned forced_pseudo_state =
@@ -1620,7 +1632,7 @@ Response InspectorCSSAgent::forcePseudoState(
       it == node_id_to_forced_pseudo_state_.end() ? 0 : it->value;
   bool need_style_recalc = forced_pseudo_state != current_forced_pseudo_state;
   if (!need_style_recalc)
-    return Response::OK();
+    return Response::Success();
 
   if (forced_pseudo_state)
     node_id_to_forced_pseudo_state_.Set(node_id, forced_pseudo_state);
@@ -1628,7 +1640,7 @@ Response InspectorCSSAgent::forcePseudoState(
     node_id_to_forced_pseudo_state_.erase(node_id);
   element->ownerDocument()->GetStyleEngine().MarkAllElementsForStyleRecalc(
       StyleChangeReasonForTracing::Create(style_change_reason::kInspector));
-  return Response::OK();
+  return Response::Success();
 }
 
 std::unique_ptr<protocol::CSS::CSSMedia> InspectorCSSAgent::BuildMediaObject(
@@ -1933,22 +1945,22 @@ InspectorStyleSheet* InspectorCSSAgent::ViaInspectorStyleSheet(
 }
 
 Response InspectorCSSAgent::AssertEnabled() {
-  return enable_completed_ ? Response::OK()
-                           : Response::Error("CSS agent was not enabled");
+  return enable_completed_ ? Response::Success()
+                           : Response::ServerError("CSS agent was not enabled");
 }
 
 Response InspectorCSSAgent::AssertInspectorStyleSheetForId(
     const String& style_sheet_id,
     InspectorStyleSheet*& result) {
   Response response = AssertEnabled();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   IdToInspectorStyleSheet::iterator it =
       id_to_inspector_style_sheet_.find(style_sheet_id);
   if (it == id_to_inspector_style_sheet_.end())
-    return Response::Error("No style sheet with given id found");
+    return Response::ServerError("No style sheet with given id found");
   result = it->value.Get();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::AssertStyleSheetForId(
@@ -1957,16 +1969,16 @@ Response InspectorCSSAgent::AssertStyleSheetForId(
   InspectorStyleSheet* style_sheet = nullptr;
   Response response =
       AssertInspectorStyleSheetForId(style_sheet_id, style_sheet);
-  if (response.isSuccess()) {
+  if (response.IsSuccess()) {
     result = style_sheet;
     return response;
   }
   IdToInspectorStyleSheetForInlineStyle::iterator it =
       id_to_inspector_style_sheet_for_inline_style_.find(style_sheet_id);
   if (it == id_to_inspector_style_sheet_for_inline_style_.end())
-    return Response::Error("No style sheet with given id found");
+    return Response::ServerError("No style sheet with given id found");
   result = it->value.Get();
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::CSS::StyleSheetOrigin InspectorCSSAgent::DetectOrigin(
@@ -2202,19 +2214,21 @@ Response InspectorCSSAgent::setEffectivePropertyValueForNode(
     const String& value) {
   Element* element = nullptr;
   Response response = dom_agent_->AssertElement(node_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (element->GetPseudoId())
-    return Response::Error("Elements is pseudo");
+    return Response::ServerError("Elements is pseudo");
 
   Document* owner_document = element->ownerDocument();
-  if (!owner_document->IsActive())
-    return Response::Error("Can't edit a node from a non-active document");
+  if (!owner_document->IsActive()) {
+    return Response::ServerError(
+        "Can't edit a node from a non-active document");
+  }
 
   CSSPropertyID property =
       cssPropertyID(owner_document->ToExecutionContext(), property_name);
   if (!isValidCSSPropertyID(property))
-    return Response::Error("Invalid property name");
+    return Response::ServerError("Invalid property name");
 
   CSSPropertyID property_id =
       cssPropertyID(owner_document->ToExecutionContext(), property_name);
@@ -2222,7 +2236,7 @@ Response InspectorCSSAgent::setEffectivePropertyValueForNode(
   CSSStyleDeclaration* style =
       FindEffectiveDeclaration(property_class, MatchingStyles(element));
   if (!style)
-    return Response::Error("Can't find a style to edit");
+    return Response::ServerError("Can't find a style to edit");
 
   bool force_important = false;
   InspectorStyleSheetBase* inspector_style_sheet = nullptr;
@@ -2241,7 +2255,7 @@ Response InspectorCSSAgent::setEffectivePropertyValueForNode(
   }
 
   if (!source_data)
-    return Response::Error("Can't find a source to edit");
+    return Response::ServerError("Can't find a source to edit");
 
   Vector<StylePropertyShorthand, 4> shorthands;
   getMatchingShorthandsForLonghand(property_id, &shorthands);
@@ -2313,7 +2327,7 @@ Response InspectorCSSAgent::getBackgroundColors(
     Maybe<String>* computed_font_weight) {
   Element* element = nullptr;
   Response response = dom_agent_->AssertElement(node_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Vector<Color> bgcolors;
@@ -2332,7 +2346,7 @@ Response InspectorCSSAgent::getBackgroundColors(
     *computed_font_size = fs;
   if (!fw.IsEmpty())
     *computed_font_weight = fw;
-  return Response::OK();
+  return Response::Success();
 }
 
 // static
@@ -2409,7 +2423,7 @@ Response InspectorCSSAgent::startRuleUsageTracking() {
     document->UpdateStyleAndLayoutTree();
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorCSSAgent::stopRuleUsageTracking(
@@ -2426,7 +2440,7 @@ Response InspectorCSSAgent::takeCoverageDelta(
     std::unique_ptr<protocol::Array<protocol::CSS::RuleUsage>>* result,
     double* out_timestamp) {
   if (!tracker_)
-    return Response::Error("CSS rule usage tracking is not enabled");
+    return Response::ServerError("CSS rule usage tracking is not enabled");
 
   StyleRuleUsageTracker::RuleListByStyleSheet coverage_delta =
       tracker_->TakeDelta();
@@ -2460,7 +2474,7 @@ Response InspectorCSSAgent::takeCoverageDelta(
     }
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorCSSAgent::Trace(Visitor* visitor) {

third_party/blink/renderer/core/inspector/inspector_dom_agent.cc

@@ -155,9 +155,10 @@ Response InspectorDOMAgent::ToResponse(ExceptionState& exception_state) {
                                    exception_state.CodeAs<DOMExceptionCode>()) +
                                    " "
                              : g_empty_string;
-    return Response::Error(name_prefix + exception_state.Message());
+    String msg = name_prefix + exception_state.Message();
+    return Response::ServerError(msg.Utf8());
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::DOM::PseudoType InspectorDOMAgent::ProtocolPseudoElementType(
@@ -351,8 +352,8 @@ void InspectorDOMAgent::Unbind(Node* node, NodeToIdMap* nodes_map) {
 Response InspectorDOMAgent::AssertNode(int node_id, Node*& node) {
   node = NodeForId(node_id);
   if (!node)
-    return Response::Error("Could not find node with given id");
-  return Response::OK();
+    return Response::ServerError("Could not find node with given id");
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::AssertNode(
@@ -365,27 +366,27 @@ Response InspectorDOMAgent::AssertNode(
 
   if (backend_node_id.isJust()) {
     node = DOMNodeIds::NodeForId(backend_node_id.fromJust());
-    return !node ? Response::Error("No node found for given backend id")
-                 : Response::OK();
+    return !node ? Response::ServerError("No node found for given backend id")
+                 : Response::Success();
   }
 
   if (object_id.isJust())
     return NodeForRemoteObjectId(object_id.fromJust(), node);
 
-  return Response::Error(
+  return Response::ServerError(
       "Either nodeId, backendNodeId or objectId must be specified");
 }
 
 Response InspectorDOMAgent::AssertElement(int node_id, Element*& element) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   element = DynamicTo<Element>(node);
   if (!element)
-    return Response::Error("Node is not an Element");
-  return Response::OK();
+    return Response::ServerError("Node is not an Element");
+  return Response::Success();
 }
 
 // static
@@ -404,45 +405,49 @@ ShadowRoot* InspectorDOMAgent::UserAgentShadowRoot(Node* node) {
 
 Response InspectorDOMAgent::AssertEditableNode(int node_id, Node*& node) {
   Response response = AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   if (node->IsInShadowTree()) {
     if (IsA<ShadowRoot>(node))
-      return Response::Error("Cannot edit shadow roots");
-    if (UserAgentShadowRoot(node))
-      return Response::Error("Cannot edit nodes from user-agent shadow trees");
+      return Response::ServerError("Cannot edit shadow roots");
+    if (UserAgentShadowRoot(node)) {
+      return Response::ServerError(
+          "Cannot edit nodes from user-agent shadow trees");
+    }
   }
 
   if (node->IsPseudoElement())
-    return Response::Error("Cannot edit pseudo elements");
-  return Response::OK();
+    return Response::ServerError("Cannot edit pseudo elements");
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::AssertEditableChildNode(Element* parent_element,
                                                     int node_id,
                                                     Node*& node) {
   Response response = AssertEditableNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
-  if (node->parentNode() != parent_element)
-    return Response::Error("Anchor node must be child of the target element");
-  return Response::OK();
+  if (node->parentNode() != parent_element) {
+    return Response::ServerError(
+        "Anchor node must be child of the target element");
+  }
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::AssertEditableElement(int node_id,
                                                   Element*& element) {
   Response response = AssertElement(node_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
-
-  if (element->IsInShadowTree() && UserAgentShadowRoot(element))
-    return Response::Error("Cannot edit elements from user-agent shadow trees");
-
+  if (element->IsInShadowTree() && UserAgentShadowRoot(element)) {
+    return Response::ServerError(
+        "Cannot edit elements from user-agent shadow trees");
+  }
   if (element->IsPseudoElement())
-    return Response::Error("Cannot edit pseudo elements");
+    return Response::ServerError("Cannot edit pseudo elements");
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorDOMAgent::EnableAndReset() {
@@ -456,18 +461,18 @@ void InspectorDOMAgent::EnableAndReset() {
 Response InspectorDOMAgent::enable() {
   if (!enabled_.Get())
     EnableAndReset();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::disable() {
   if (!enabled_.Get())
-    return Response::Error("DOM agent hasn't been enabled");
+    return Response::ServerError("DOM agent hasn't been enabled");
   enabled_.Clear();
   instrumenting_agents_->RemoveInspectorDOMAgent(this);
   history_.Clear();
   dom_editor_.Clear();
   SetDocument(nullptr);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getDocument(
@@ -478,7 +483,7 @@ Response InspectorDOMAgent::getDocument(
   enable();
 
   if (!document_)
-    return Response::Error("Document is not available");
+    return Response::ServerError("Document is not available");
 
   DiscardFrontendBindings();
 
@@ -489,7 +494,7 @@ Response InspectorDOMAgent::getDocument(
   *root = BuildObjectForNode(document_.Get(), sanitized_depth,
                              pierce.fromMaybe(false),
                              document_node_to_id_map_.Get());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getFlattenedDocument(
@@ -497,10 +502,10 @@ Response InspectorDOMAgent::getFlattenedDocument(
     Maybe<bool> pierce,
     std::unique_ptr<protocol::Array<protocol::DOM::Node>>* nodes) {
   if (!enabled_.Get())
-    return Response::Error("DOM agent hasn't been enabled");
+    return Response::ServerError("DOM agent hasn't been enabled");
 
   if (!document_)
-    return Response::Error("Document is not available");
+    return Response::ServerError("Document is not available");
 
   DiscardFrontendBindings();
 
@@ -512,7 +517,7 @@ Response InspectorDOMAgent::getFlattenedDocument(
   (*nodes)->emplace_back(BuildObjectForNode(
       document_.Get(), sanitized_depth, pierce.fromMaybe(false),
       document_node_to_id_map_.Get(), nodes->get()));
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorDOMAgent::PushChildNodesToFrontend(int node_id,
@@ -578,7 +583,7 @@ Response InspectorDOMAgent::collectClassNamesFromSubtree(
   auto* parent_element = DynamicTo<Element>(parent_node);
   if (!parent_element && !parent_node->IsDocumentNode() &&
       !parent_node->IsDocumentFragment())
-    return Response::Error("No suitable node with given id found");
+    return Response::ServerError("No suitable node with given id found");
 
   for (Node* node = parent_node; node;
        node = FlatTreeTraversal::Next(*node, parent_node)) {
@@ -592,7 +597,7 @@ Response InspectorDOMAgent::collectClassNamesFromSubtree(
   }
   for (const String& class_name : unique_names)
     (*class_names)->emplace_back(class_name);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::requestChildNodes(
@@ -601,7 +606,7 @@ Response InspectorDOMAgent::requestChildNodes(
     Maybe<bool> maybe_taverse_frames) {
   int sanitized_depth = depth.fromMaybe(1);
   if (sanitized_depth == 0 || sanitized_depth < -1) {
-    return Response::Error(
+    return Response::ServerError(
         "Please provide a positive integer as a depth or -1 for entire "
         "subtree");
   }
@@ -610,7 +615,7 @@ Response InspectorDOMAgent::requestChildNodes(
 
   PushChildNodesToFrontend(node_id, sanitized_depth,
                            maybe_taverse_frames.fromMaybe(false));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::querySelector(int node_id,
@@ -619,21 +624,21 @@ Response InspectorDOMAgent::querySelector(int node_id,
   *element_id = 0;
   Node* node = nullptr;
   Response response = AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   auto* container_node = DynamicTo<ContainerNode>(node);
   if (!container_node)
-    return Response::Error("Not a container node");
+    return Response::ServerError("Not a container node");
 
   DummyExceptionStateForTesting exception_state;
   Element* element =
       container_node->QuerySelector(AtomicString(selectors), exception_state);
   if (exception_state.HadException())
-    return Response::Error("DOM Error while querying");
+    return Response::ServerError("DOM Error while querying");
 
   if (element)
     *element_id = PushNodePathToFrontend(element);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::querySelectorAll(
@@ -642,23 +647,23 @@ Response InspectorDOMAgent::querySelectorAll(
     std::unique_ptr<protocol::Array<int>>* result) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   auto* container_node = DynamicTo<ContainerNode>(node);
   if (!container_node)
-    return Response::Error("Not a container node");
+    return Response::ServerError("Not a container node");
 
   DummyExceptionStateForTesting exception_state;
   StaticElementList* elements = container_node->QuerySelectorAll(
       AtomicString(selectors), exception_state);
   if (exception_state.HadException())
-    return Response::Error("DOM Error while querying");
+    return Response::ServerError("DOM Error while querying");
 
   *result = std::make_unique<protocol::Array<int>>();
 
   for (unsigned i = 0; i < elements->length(); ++i)
     (*result)->emplace_back(PushNodePathToFrontend(elements->item(i)));
-  return Response::OK();
+  return Response::Success();
 }
 
 int InspectorDOMAgent::PushNodePathToFrontend(Node* node_to_push,
@@ -729,7 +734,7 @@ Response InspectorDOMAgent::setAttributeValue(int element_id,
                                               const String& value) {
   Element* element = nullptr;
   Response response = AssertEditableElement(element_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   return dom_editor_->SetAttribute(element, name, value);
 }
@@ -739,7 +744,7 @@ Response InspectorDOMAgent::setAttributesAsText(int element_id,
                                                 Maybe<String> name) {
   Element* element = nullptr;
   Response response = AssertEditableElement(element_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   String markup = "<span " + text + "></span>";
@@ -761,7 +766,7 @@ Response InspectorDOMAgent::setAttributesAsText(int element_id,
 
   Element* parsed_element = DynamicTo<Element>(fragment->firstChild());
   if (!parsed_element)
-    return Response::Error("Could not parse value as attributes");
+    return Response::ServerError("Could not parse value as attributes");
 
   String case_adjusted_name = should_ignore_case
                                   ? name.fromMaybe("").DeprecatedLower()
@@ -781,7 +786,7 @@ Response InspectorDOMAgent::setAttributesAsText(int element_id,
         name.isJust() && attribute_name == case_adjusted_name;
     Response response =
         dom_editor_->SetAttribute(element, attribute_name, attribute.Value());
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
 
@@ -789,14 +794,14 @@ Response InspectorDOMAgent::setAttributesAsText(int element_id,
       !name.fromJust().StripWhiteSpace().IsEmpty()) {
     return dom_editor_->RemoveAttribute(element, case_adjusted_name);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::removeAttribute(int element_id,
                                             const String& name) {
   Element* element = nullptr;
   Response response = AssertEditableElement(element_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   return dom_editor_->RemoveAttribute(element, name);
@@ -805,12 +810,12 @@ Response InspectorDOMAgent::removeAttribute(int element_id,
 Response InspectorDOMAgent::removeNode(int node_id) {
   Node* node = nullptr;
   Response response = AssertEditableNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   ContainerNode* parent_node = node->parentNode();
   if (!parent_node)
-    return Response::Error("Cannot remove detached node");
+    return Response::ServerError("Cannot remove detached node");
 
   return dom_editor_->RemoveChild(parent_node, node);
 }
@@ -822,7 +827,7 @@ Response InspectorDOMAgent::setNodeName(int node_id,
 
   Element* old_element = nullptr;
   Response response = AssertElement(node_id, old_element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -838,7 +843,7 @@ Response InspectorDOMAgent::setNodeName(int node_id,
   for (Node* child = old_element->firstChild(); child;
        child = old_element->firstChild()) {
     response = dom_editor_->InsertBefore(new_elem, child, nullptr);
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
 
@@ -846,16 +851,16 @@ Response InspectorDOMAgent::setNodeName(int node_id,
   ContainerNode* parent = old_element->parentNode();
   response =
       dom_editor_->InsertBefore(parent, new_elem, old_element->nextSibling());
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   response = dom_editor_->RemoveChild(parent, old_element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   *new_id = PushNodePathToFrontend(new_elem);
   if (children_requested_.Contains(node_id))
     PushChildNodesToFrontend(*new_id);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getOuterHTML(Maybe<int> node_id,
@@ -864,11 +869,11 @@ Response InspectorDOMAgent::getOuterHTML(Maybe<int> node_id,
                                          WTF::String* outer_html) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, backend_node_id, object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   *outer_html = CreateMarkup(node);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::setOuterHTML(int node_id,
@@ -877,28 +882,28 @@ Response InspectorDOMAgent::setOuterHTML(int node_id,
     DCHECK(document_);
     DOMPatchSupport dom_patch_support(dom_editor_.Get(), *document_.Get());
     dom_patch_support.PatchDocument(outer_html);
-    return Response::OK();
+    return Response::Success();
   }
 
   Node* node = nullptr;
   Response response = AssertEditableNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Document* document =
       IsA<Document>(node) ? To<Document>(node) : node->ownerDocument();
   if (!document ||
       (!IsA<HTMLDocument>(document) && !IsA<XMLDocument>(document)))
-    return Response::Error("Not an HTML/XML document");
+    return Response::ServerError("Not an HTML/XML document");
 
   Node* new_node = nullptr;
   response = dom_editor_->SetOuterHTML(node, outer_html, &new_node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   if (!new_node) {
     // The only child node has been deleted.
-    return Response::OK();
+    return Response::Success();
   }
 
   int new_id = PushNodePathToFrontend(new_node);
@@ -906,17 +911,17 @@ Response InspectorDOMAgent::setOuterHTML(int node_id,
   bool children_requested = children_requested_.Contains(node_id);
   if (children_requested)
     PushChildNodesToFrontend(new_id);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::setNodeValue(int node_id, const String& value) {
   Node* node = nullptr;
   Response response = AssertEditableNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   if (node->getNodeType() != Node::kTextNode)
-    return Response::Error("Can only set value of text nodes");
+    return Response::ServerError("Can only set value of text nodes");
 
   return dom_editor_->ReplaceWholeText(To<Text>(node), value);
 }
@@ -958,7 +963,7 @@ Response InspectorDOMAgent::performSearch(
     String* search_id,
     int* result_count) {
   if (!enabled_.Get())
-    return Response::Error("DOM agent is not enabled");
+    return Response::ServerError("DOM agent is not enabled");
 
   // FIXME: Few things are missing here:
   // 1) Search works with node granularity - number of matches within node is
@@ -1100,7 +1105,7 @@ Response InspectorDOMAgent::performSearch(
     results_it->push_back(result);
 
   *result_count = results_it->size();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getSearchResults(
@@ -1110,21 +1115,21 @@ Response InspectorDOMAgent::getSearchResults(
     std::unique_ptr<protocol::Array<int>>* node_ids) {
   SearchResults::iterator it = search_results_.find(search_id);
   if (it == search_results_.end())
-    return Response::Error("No search session with given id found");
+    return Response::ServerError("No search session with given id found");
 
   int size = it->value.size();
   if (from_index < 0 || to_index > size || from_index >= to_index)
-    return Response::Error("Invalid search result range");
+    return Response::ServerError("Invalid search result range");
 
   *node_ids = std::make_unique<protocol::Array<int>>();
   for (int i = from_index; i < to_index; ++i)
     (*node_ids)->emplace_back(PushNodePathToFrontend((it->value)[i].Get()));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::discardSearchResults(const String& search_id) {
   search_results_.erase(search_id);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::NodeForRemoteObjectId(const String& object_id,
@@ -1135,15 +1140,15 @@ Response InspectorDOMAgent::NodeForRemoteObjectId(const String& object_id,
   std::unique_ptr<v8_inspector::StringBuffer> error;
   if (!v8_session_->unwrapObject(&error, ToV8InspectorStringView(object_id),
                                  &value, &context, nullptr))
-    return Response::Error(ToCoreString(std::move(error)));
+    return Response::ServerError(ToCoreString(std::move(error)).Utf8());
   if (!V8Node::HasInstance(value, isolate_))
-    return Response::Error("Object id doesn't reference a Node");
+    return Response::ServerError("Object id doesn't reference a Node");
   node = V8Node::ToImpl(v8::Local<v8::Object>::Cast(value));
   if (!node) {
-    return Response::Error(
+    return Response::ServerError(
         "Couldn't convert object with given objectId to Node");
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::copyTo(int node_id,
@@ -1152,33 +1157,33 @@ Response InspectorDOMAgent::copyTo(int node_id,
                                    int* new_node_id) {
   Node* node = nullptr;
   Response response = AssertEditableNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Element* target_element = nullptr;
   response = AssertEditableElement(target_element_id, target_element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Node* anchor_node = nullptr;
   if (anchor_node_id.isJust() && anchor_node_id.fromJust()) {
     response = AssertEditableChildNode(target_element,
                                        anchor_node_id.fromJust(), anchor_node);
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
 
   // The clone is deep by default.
   Node* cloned_node = node->cloneNode(true);
   if (!cloned_node)
-    return Response::Error("Failed to clone node");
+    return Response::ServerError("Failed to clone node");
   response =
       dom_editor_->InsertBefore(target_element, cloned_node, anchor_node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   *new_node_id = PushNodePathToFrontend(cloned_node);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::moveTo(int node_id,
@@ -1187,18 +1192,20 @@ Response InspectorDOMAgent::moveTo(int node_id,
                                    int* new_node_id) {
   Node* node = nullptr;
   Response response = AssertEditableNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Element* target_element = nullptr;
   response = AssertEditableElement(target_element_id, target_element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Node* current = target_element;
   while (current) {
-    if (current == node)
-      return Response::Error("Unable to move node into self or descendant");
+    if (current == node) {
+      return Response::ServerError(
+          "Unable to move node into self or descendant");
+    }
     current = current->parentNode();
   }
 
@@ -1206,21 +1213,21 @@ Response InspectorDOMAgent::moveTo(int node_id,
   if (anchor_node_id.isJust() && anchor_node_id.fromJust()) {
     response = AssertEditableChildNode(target_element,
                                        anchor_node_id.fromJust(), anchor_node);
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
 
   response = dom_editor_->InsertBefore(target_element, node, anchor_node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   *new_node_id = PushNodePathToFrontend(node);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::undo() {
   if (!enabled_.Get())
-    return Response::Error("DOM agent is not enabled");
+    return Response::ServerError("DOM agent is not enabled");
   DummyExceptionStateForTesting exception_state;
   history_->Undo(exception_state);
   return InspectorDOMAgent::ToResponse(exception_state);
@@ -1228,7 +1235,7 @@ Response InspectorDOMAgent::undo() {
 
 Response InspectorDOMAgent::redo() {
   if (!enabled_.Get())
-    return Response::Error("DOM agent is not enabled");
+    return Response::ServerError("DOM agent is not enabled");
   DummyExceptionStateForTesting exception_state;
   history_->Redo(exception_state);
   return InspectorDOMAgent::ToResponse(exception_state);
@@ -1236,7 +1243,7 @@ Response InspectorDOMAgent::redo() {
 
 Response InspectorDOMAgent::markUndoableState() {
   history_->MarkUndoableState();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::focus(Maybe<int> node_id,
@@ -1244,16 +1251,16 @@ Response InspectorDOMAgent::focus(Maybe<int> node_id,
                                   Maybe<String> object_id) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, backend_node_id, object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   auto* element = DynamicTo<Element>(node);
   if (!element)
-    return Response::Error("Node is not an Element");
+    return Response::ServerError("Node is not an Element");
   element->GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kInspector);
   if (!element->IsFocusable())
-    return Response::Error("Element is not focusable");
+    return Response::ServerError("Element is not focusable");
   element->focus();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::setFileInputFiles(
@@ -1263,24 +1270,24 @@ Response InspectorDOMAgent::setFileInputFiles(
     Maybe<String> object_id) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, backend_node_id, object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   auto* html_input_element = DynamicTo<HTMLInputElement>(node);
   if (!html_input_element ||
       html_input_element->type() != input_type_names::kFile)
-    return Response::Error("Node is not a file input element");
+    return Response::ServerError("Node is not a file input element");
 
   Vector<String> paths;
   for (const String& file : *files)
     paths.push_back(file);
   To<HTMLInputElement>(node)->SetFilesFromPaths(paths);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::setNodeStackTracesEnabled(bool enable) {
   capture_node_stack_traces_.Set(enable);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getNodeStackTraces(
@@ -1289,7 +1296,7 @@ Response InspectorDOMAgent::getNodeStackTraces(
         creation) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   InspectorSourceLocation* creation_inspector_source_location =
@@ -1299,7 +1306,7 @@ Response InspectorDOMAgent::getNodeStackTraces(
         creation_inspector_source_location->GetSourceLocation();
     *creation = source_location.BuildInspectorObject();
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getBoxModel(
@@ -1309,13 +1316,13 @@ Response InspectorDOMAgent::getBoxModel(
     std::unique_ptr<protocol::DOM::BoxModel>* model) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, backend_node_id, object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   bool result = InspectorHighlight::GetBoxModel(node, model, true);
   if (!result)
-    return Response::Error("Could not compute box model.");
-  return Response::OK();
+    return Response::ServerError("Could not compute box model.");
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getContentQuads(
@@ -1325,12 +1332,12 @@ Response InspectorDOMAgent::getContentQuads(
     std::unique_ptr<protocol::Array<protocol::Array<double>>>* quads) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, backend_node_id, object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   bool result = InspectorHighlight::GetContentQuads(node, quads);
   if (!result)
-    return Response::Error("Could not compute content quads.");
-  return Response::OK();
+    return Response::ServerError("Could not compute content quads.");
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getNodeForLocation(
@@ -1362,7 +1369,7 @@ Response InspectorDOMAgent::getNodeForLocation(
   while (node && node->getNodeType() == Node::kTextNode)
     node = node->parentNode();
   if (!node)
-    return Response::Error("No node found at given location");
+    return Response::ServerError("No node found at given location");
   *backend_node_id = IdentifiersFactory::IntIdForNode(node);
   LocalFrame* frame = node->GetDocument().GetFrame();
   *frame_id = IdentifiersFactory::FrameId(frame);
@@ -1370,7 +1377,7 @@ Response InspectorDOMAgent::getNodeForLocation(
       document_node_to_id_map_->Contains(document_)) {
     *node_id = PushNodePathToFrontend(node);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::resolveNode(
@@ -1383,8 +1390,10 @@ Response InspectorDOMAgent::resolveNode(
   String object_group_name = object_group.fromMaybe("");
   Node* node = nullptr;
 
-  if (node_id.isJust() == backend_node_id.isJust())
-    return Response::Error("Either nodeId or backendNodeId must be specified.");
+  if (node_id.isJust() == backend_node_id.isJust()) {
+    return Response::ServerError(
+        "Either nodeId or backendNodeId must be specified.");
+  }
 
   if (node_id.isJust())
     node = NodeForId(node_id.fromJust());
@@ -1392,14 +1401,14 @@ Response InspectorDOMAgent::resolveNode(
     node = DOMNodeIds::NodeForId(backend_node_id.fromJust());
 
   if (!node)
-    return Response::Error("No node with given id found");
+    return Response::ServerError("No node with given id found");
   *result = ResolveNode(v8_session_, node, object_group_name,
                         std::move(execution_context_id));
   if (!*result) {
-    return Response::Error(
+    return Response::ServerError(
         "Node with given id does not belong to the document");
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getAttributes(
@@ -1407,20 +1416,20 @@ Response InspectorDOMAgent::getAttributes(
     std::unique_ptr<protocol::Array<String>>* result) {
   Element* element = nullptr;
   Response response = AssertElement(node_id, element);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   *result = BuildArrayForElementAttributes(element);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::requestNode(const String& object_id, int* node_id) {
   Node* node = nullptr;
   Response response = NodeForRemoteObjectId(object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   *node_id = PushNodePathToFrontend(node);
-  return Response::OK();
+  return Response::Success();
 }
 
 // static
@@ -2185,19 +2194,19 @@ Node* InspectorDOMAgent::NodeForPath(const String& path) {
 Response InspectorDOMAgent::pushNodeByPathToFrontend(const String& path,
                                                      int* node_id) {
   if (!enabled_.Get())
-    return Response::Error("DOM agent is not enabled");
+    return Response::ServerError("DOM agent is not enabled");
   if (Node* node = NodeForPath(path))
     *node_id = PushNodePathToFrontend(node);
   else
-    return Response::Error("No node with given path found");
-  return Response::OK();
+    return Response::ServerError("No node with given path found");
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::pushNodesByBackendIdsToFrontend(
     std::unique_ptr<protocol::Array<int>> backend_node_ids,
     std::unique_ptr<protocol::Array<int>>* result) {
   if (!document_ || !document_node_to_id_map_->Contains(document_))
-    return Response::Error("Document needs to be requested first");
+    return Response::ServerError("Document needs to be requested first");
 
   *result = std::make_unique<protocol::Array<int>>();
   for (int id : *backend_node_ids) {
@@ -2208,7 +2217,7 @@ Response InspectorDOMAgent::pushNodesByBackendIdsToFrontend(
     else
       (*result)->emplace_back(0);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 class InspectableNode final
@@ -2228,10 +2237,10 @@ class InspectableNode final
 Response InspectorDOMAgent::setInspectedNode(int node_id) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   v8_session_->addInspectedObject(std::make_unique<InspectableNode>(node));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getRelayoutBoundary(
@@ -2239,11 +2248,11 @@ Response InspectorDOMAgent::getRelayoutBoundary(
     int* relayout_boundary_node_id) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   LayoutObject* layout_object = node->GetLayoutObject();
   if (!layout_object) {
-    return Response::Error(
+    return Response::ServerError(
         "No layout object for node, perhaps orphan or hidden node");
   }
   while (layout_object && !layout_object->IsDocumentElement() &&
@@ -2252,7 +2261,7 @@ Response InspectorDOMAgent::getRelayoutBoundary(
   Node* result_node =
       layout_object ? layout_object->GeneratingNode() : node->ownerDocument();
   *relayout_boundary_node_id = PushNodePathToFrontend(result_node);
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response InspectorDOMAgent::describeNode(
@@ -2264,13 +2273,13 @@ protocol::Response InspectorDOMAgent::describeNode(
     std::unique_ptr<protocol::DOM::Node>* result) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, backend_node_id, object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (!node)
-    return Response::Error("Node not found");
+    return Response::ServerError("Node not found");
   *result = BuildObjectForNode(node, depth.fromMaybe(0),
                                pierce.fromMaybe(false), nullptr, nullptr);
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response InspectorDOMAgent::scrollIntoViewIfNeeded(
@@ -2280,15 +2289,15 @@ protocol::Response InspectorDOMAgent::scrollIntoViewIfNeeded(
     protocol::Maybe<protocol::DOM::Rect> rect) {
   Node* node = nullptr;
   Response response = AssertNode(node_id, backend_node_id, object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   node->GetDocument().EnsurePaintLocationDataValidForNode(
       node, DocumentUpdateReason::kInspector);
   if (!node->isConnected())
-    return Response::Error("Node is detached from document");
+    return Response::ServerError("Node is detached from document");
   LayoutObject* layout_object = node->GetLayoutObject();
   if (!layout_object)
-    return Response::Error("Node does not have a layout object");
+    return Response::ServerError("Node does not have a layout object");
   PhysicalRect rect_to_scroll = PhysicalRect::EnclosingRect(
       layout_object->AbsoluteBoundingBoxFloatRect());
   if (rect.isJust()) {
@@ -2307,7 +2316,7 @@ protocol::Response InspectorDOMAgent::scrollIntoViewIfNeeded(
           true /* make_visible_in_visual_viewport */,
           mojom::blink::ScrollBehavior::kInstant,
           true /* is_for_scroll_sequence */, false /* zoom_into_rect */));
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response InspectorDOMAgent::getFrameOwner(
@@ -2329,10 +2338,10 @@ protocol::Response InspectorDOMAgent::getFrameOwner(
     }
   }
   if (!frame)
-    return Response::Error("Frame with the given id was not found.");
+    return Response::ServerError("Frame with the given id was not found.");
   auto* frame_owner = DynamicTo<HTMLFrameOwnerElement>(frame->Owner());
   if (!frame_owner) {
-    return Response::Error(
+    return Response::ServerError(
         "Frame with the given id does not belong to the target.");
   }
 
@@ -2342,7 +2351,7 @@ protocol::Response InspectorDOMAgent::getFrameOwner(
       document_node_to_id_map_->Contains(document_)) {
     *node_id = PushNodePathToFrontend(frame_owner);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMAgent::getFileInfo(const String& object_id, String* path) {
@@ -2352,18 +2361,18 @@ Response InspectorDOMAgent::getFileInfo(const String& object_id, String* path) {
   std::unique_ptr<v8_inspector::StringBuffer> error;
   if (!v8_session_->unwrapObject(&error, ToV8InspectorStringView(object_id),
                                  &value, &context, nullptr))
-    return Response::Error(ToCoreString(std::move(error)));
+    return Response::ServerError(ToCoreString(std::move(error)).Utf8());
 
   if (!V8File::HasInstance(value, isolate_))
-    return Response::Error("Object id doesn't reference a File");
+    return Response::ServerError("Object id doesn't reference a File");
   File* file = V8File::ToImpl(v8::Local<v8::Object>::Cast(value));
   if (!file) {
-    return Response::Error(
+    return Response::ServerError(
         "Couldn't convert object with given objectId to File");
   }
 
   *path = file->GetPath();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorDOMAgent::Trace(Visitor* visitor) {

third_party/blink/renderer/core/inspector/inspector_dom_debugger_agent.cc

@@ -224,7 +224,7 @@ Response InspectorDOMDebuggerAgent::disable() {
   SetEnabled(false);
   dom_breakpoints_.clear();
   agent_state_.ClearAllFields();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorDOMDebuggerAgent::Restore() {
@@ -248,11 +248,11 @@ Response InspectorDOMDebuggerAgent::setInstrumentationBreakpoint(
 Response InspectorDOMDebuggerAgent::SetBreakpoint(const String& event_name,
                                                   const String& target_name) {
   if (event_name.IsEmpty())
-    return Response::Error("Event name is empty");
+    return Response::ServerError("Event name is empty");
   event_listener_breakpoints_.Set(
       EventListenerBreakpointKey(event_name, target_name), true);
   DidAddBreakpoint();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMDebuggerAgent::removeEventListenerBreakpoint(
@@ -272,11 +272,11 @@ Response InspectorDOMDebuggerAgent::RemoveBreakpoint(
     const String& event_name,
     const String& target_name) {
   if (event_name.IsEmpty())
-    return Response::Error("Event name is empty");
+    return Response::ServerError("Event name is empty");
   event_listener_breakpoints_.Clear(
       EventListenerBreakpointKey(event_name, target_name));
   DidRemoveBreakpoint();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorDOMDebuggerAgent::DidInvalidateStyleAttr(Node* node) {
@@ -316,17 +316,18 @@ void InspectorDOMDebuggerAgent::DidRemoveDOMNode(Node* node) {
 static Response DomTypeForName(const String& type_string, int& type) {
   if (type_string == "subtree-modified") {
     type = SubtreeModified;
-    return Response::OK();
+    return Response::Success();
   }
   if (type_string == "attribute-modified") {
     type = AttributeModified;
-    return Response::OK();
+    return Response::Success();
   }
   if (type_string == "node-removed") {
     type = NodeRemoved;
-    return Response::OK();
+    return Response::Success();
   }
-  return Response::Error(String("Unknown DOM breakpoint type: " + type_string));
+  return Response::ServerError(
+      String("Unknown DOM breakpoint type: " + type_string).Utf8());
 }
 
 static String DomTypeName(int type) {
@@ -348,12 +349,12 @@ Response InspectorDOMDebuggerAgent::setDOMBreakpoint(
     const String& type_string) {
   Node* node = nullptr;
   Response response = dom_agent_->AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   int type = -1;
   response = DomTypeForName(type_string, type);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   uint32_t root_bit = 1 << type;
@@ -364,7 +365,7 @@ Response InspectorDOMDebuggerAgent::setDOMBreakpoint(
       UpdateSubtreeBreakpoints(child, root_bit, true);
   }
   DidAddBreakpoint();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMDebuggerAgent::removeDOMBreakpoint(
@@ -372,12 +373,12 @@ Response InspectorDOMDebuggerAgent::removeDOMBreakpoint(
     const String& type_string) {
   Node* node = nullptr;
   Response response = dom_agent_->AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   int type = -1;
   response = DomTypeForName(type_string, type);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   uint32_t root_bit = 1 << type;
@@ -394,7 +395,7 @@ Response InspectorDOMDebuggerAgent::removeDOMBreakpoint(
       UpdateSubtreeBreakpoints(child, root_bit, false);
   }
   DidRemoveBreakpoint();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMDebuggerAgent::getEventListeners(
@@ -410,7 +411,7 @@ Response InspectorDOMDebuggerAgent::getEventListeners(
   std::unique_ptr<v8_inspector::StringBuffer> object_group;
   if (!v8_session_->unwrapObject(&error, ToV8InspectorStringView(object_id),
                                  &object, &context, &object_group)) {
-    return Response::Error(ToCoreString(std::move(error)));
+    return Response::ServerError(ToCoreString(std::move(error)).Utf8());
   }
   v8::Context::Scope scope(context);
   V8EventListenerInfoList event_information;
@@ -419,7 +420,7 @@ Response InspectorDOMDebuggerAgent::getEventListeners(
       pierce.fromMaybe(false), &event_information);
   *listeners_array = BuildObjectsForEventListeners(event_information, context,
                                                    object_group->string());
-  return Response::OK();
+  return Response::Success();
 }
 
 std::unique_ptr<protocol::Array<protocol::DOMDebugger::EventListener>>
@@ -692,7 +693,7 @@ Response InspectorDOMDebuggerAgent::setXHRBreakpoint(const String& url) {
   else
     xhr_breakpoints_.Set(url, true);
   DidAddBreakpoint();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMDebuggerAgent::removeXHRBreakpoint(const String& url) {
@@ -701,7 +702,7 @@ Response InspectorDOMDebuggerAgent::removeXHRBreakpoint(const String& url) {
   else
     xhr_breakpoints_.Clear(url);
   DidRemoveBreakpoint();
-  return Response::OK();
+  return Response::Success();
 }
 
 // Returns the breakpoint url if a match is found, or WTF::String().

third_party/blink/renderer/core/inspector/inspector_dom_snapshot_agent.cc

@@ -206,16 +206,16 @@ void InspectorDOMSnapshotAgent::Restore() {
 Response InspectorDOMSnapshotAgent::enable() {
   if (!enabled_.Get())
     EnableAndReset();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMSnapshotAgent::disable() {
   if (!enabled_.Get())
-    return Response::Error("DOM snapshot agent hasn't been enabled.");
+    return Response::ServerError("DOM snapshot agent hasn't been enabled.");
   enabled_.Clear();
   origin_url_map_.reset();
   instrumenting_agents_->RemoveInspectorDOMSnapshotAgent(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMSnapshotAgent::getSnapshot(
@@ -230,7 +230,7 @@ Response InspectorDOMSnapshotAgent::getSnapshot(
         computed_styles) {
   Document* document = inspected_frames_->Root()->GetDocument();
   if (!document)
-    return Response::Error("Document is not available");
+    return Response::ServerError("Document is not available");
   LegacyDOMSnapshotAgent legacySupport(dom_debugger_agent_,
                                        origin_url_map_.get());
   return legacySupport.GetSnapshot(
@@ -252,7 +252,7 @@ protocol::Response InspectorDOMSnapshotAgent::captureSnapshot(
 
   Document* main_document = inspected_frames_->Root()->GetDocument();
   if (!main_document)
-    return Response::Error("Document is not available");
+    return Response::ServerError("Document is not available");
 
   strings_ = std::make_unique<protocol::Array<String>>();
   documents_ = std::make_unique<
@@ -293,7 +293,7 @@ protocol::Response InspectorDOMSnapshotAgent::captureSnapshot(
   string_table_.clear();
   document_order_map_.clear();
   documents_.reset();
-  return Response::OK();
+  return Response::Success();
 }
 
 int InspectorDOMSnapshotAgent::AddString(const String& string) {

third_party/blink/renderer/core/inspector/inspector_emulation_agent.cc

@@ -160,7 +160,7 @@ Response InspectorEmulationAgent::disable() {
   if (!locale_override_.Get().IsEmpty())
     setLocaleOverride(String());
   if (!web_local_frame_)
-    return Response::OK();
+    return Response::Success();
   setScriptExecutionDisabled(false);
   setScrollbarsHidden(false);
   setDocumentCookieDisabled(false);
@@ -176,12 +176,12 @@ Response InspectorEmulationAgent::disable() {
   setCPUThrottlingRate(1);
   setFocusEmulationEnabled(false);
   setDefaultBackgroundColorOverride(Maybe<protocol::DOM::RGBA>());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorEmulationAgent::resetPageScaleFactor() {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   GetWebViewImpl()->ResetScaleStateImmediately();
   return response;
@@ -189,7 +189,7 @@ Response InspectorEmulationAgent::resetPageScaleFactor() {
 
 Response InspectorEmulationAgent::setPageScaleFactor(double page_scale_factor) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   GetWebViewImpl()->SetPageScaleFactor(static_cast<float>(page_scale_factor));
   return response;
@@ -197,7 +197,7 @@ Response InspectorEmulationAgent::setPageScaleFactor(double page_scale_factor) {
 
 Response InspectorEmulationAgent::setScriptExecutionDisabled(bool value) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (script_execution_disabled_.Get() == value)
     return response;
@@ -208,7 +208,7 @@ Response InspectorEmulationAgent::setScriptExecutionDisabled(bool value) {
 
 Response InspectorEmulationAgent::setScrollbarsHidden(bool hidden) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (scrollbars_hidden_.Get() == hidden)
     return response;
@@ -219,7 +219,7 @@ Response InspectorEmulationAgent::setScrollbarsHidden(bool hidden) {
 
 Response InspectorEmulationAgent::setDocumentCookieDisabled(bool disabled) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (document_cookie_disabled_.Get() == disabled)
     return response;
@@ -232,13 +232,14 @@ Response InspectorEmulationAgent::setTouchEmulationEnabled(
     bool enabled,
     protocol::Maybe<int> max_touch_points) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   int max_points = max_touch_points.fromMaybe(1);
   if (max_points < 1 || max_points > WebTouchEvent::kTouchesLengthCap) {
-    return Response::InvalidParams("Touch points must be between 1 and " +
-                                   String::Number(static_cast<uint16_t>(
-                                       WebTouchEvent::kTouchesLengthCap)));
+    String msg =
+        "Touch points must be between 1 and " +
+        String::Number(static_cast<uint16_t>(WebTouchEvent::kTouchesLengthCap));
+    return Response::InvalidParams(msg.Utf8());
   }
   touch_event_emulation_enabled_.Set(enabled);
   max_touch_points_.Set(max_points);
@@ -251,7 +252,7 @@ Response InspectorEmulationAgent::setEmulatedMedia(
     Maybe<String> media,
     Maybe<protocol::Array<protocol::Emulation::MediaFeature>> features) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (media.isJust()) {
     auto mediaValue = media.takeJust();
@@ -282,7 +283,7 @@ Response InspectorEmulationAgent::setEmulatedMedia(
 Response InspectorEmulationAgent::setEmulatedVisionDeficiency(
     const String& type) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   VisionDeficiency vision_deficiency;
@@ -318,7 +319,7 @@ Response InspectorEmulationAgent::setEmulatedVisionDeficiency(
 
 Response InspectorEmulationAgent::setCPUThrottlingRate(double rate) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   scheduler::ThreadCPUThrottler::GetInstance()->SetThrottlingRate(rate);
   return response;
@@ -326,7 +327,7 @@ Response InspectorEmulationAgent::setCPUThrottlingRate(double rate) {
 
 Response InspectorEmulationAgent::setFocusEmulationEnabled(bool enabled) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   emulate_focus_.Set(enabled);
   GetWebViewImpl()->GetPage()->GetFocusController().SetFocusEmulationEnabled(
@@ -342,7 +343,7 @@ Response InspectorEmulationAgent::setVirtualTimePolicy(
     protocol::Maybe<double> initial_virtual_time,
     double* virtual_time_ticks_base_ms) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   virtual_time_policy_.Set(policy);
 
@@ -463,7 +464,7 @@ void InspectorEmulationAgent::PrepareRequest(
 Response InspectorEmulationAgent::setNavigatorOverrides(
     const String& platform) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   navigator_platform_override_.Set(platform);
   GetWebViewImpl()->GetPage()->GetSettings().SetNavigatorPlatformOverride(
@@ -490,13 +491,13 @@ void InspectorEmulationAgent::VirtualTimeBudgetExpired() {
 Response InspectorEmulationAgent::setDefaultBackgroundColorOverride(
     Maybe<protocol::DOM::RGBA> color) {
   Response response = AssertPage();
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (!color.isJust()) {
     // Clear the override and state.
     GetWebViewImpl()->ClearBaseBackgroundColorOverride();
     default_background_color_override_rgba_.Clear();
-    return Response::OK();
+    return Response::Success();
   }
 
   blink::protocol::DOM::RGBA* rgba = color.fromJust();
@@ -505,7 +506,7 @@ Response InspectorEmulationAgent::setDefaultBackgroundColorOverride(
   int alpha = static_cast<int>(lroundf(255.0f * rgba->getA(1.0f)));
   GetWebViewImpl()->SetBaseBackgroundColorOverride(
       Color(rgba->getR(), rgba->getG(), rgba->getB(), alpha).Rgb());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorEmulationAgent::setDeviceMetricsOverride(
@@ -547,7 +548,7 @@ Response InspectorEmulationAgent::setUserAgentOverride(
     GetWebViewImpl()->GetPage()->GetSettings().SetNavigatorPlatformOverride(
         navigator_platform_override_.Get());
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorEmulationAgent::setLocaleOverride(
@@ -555,14 +556,15 @@ Response InspectorEmulationAgent::setLocaleOverride(
   // Only allow resetting overrides set by the same agent.
   if (locale_override_.Get().IsEmpty() &&
       LocaleController::instance().has_locale_override()) {
-    return Response::Error("Another locale override is already in effect");
+    return Response::ServerError(
+        "Another locale override is already in effect");
   }
   String locale = maybe_locale.fromMaybe(String());
   String error = LocaleController::instance().SetLocaleOverride(locale);
   if (!error.IsEmpty())
-    return Response::Error(error);
+    return Response::ServerError(error.Utf8());
   locale_override_.Set(locale);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorEmulationAgent::setTimezoneOverride(
@@ -572,14 +574,15 @@ Response InspectorEmulationAgent::setTimezoneOverride(
     timezone_override_ = TimeZoneController::SetTimeZoneOverride(timezone_id);
     if (!timezone_override_) {
       return TimeZoneController::HasTimeZoneOverride()
-                 ? Response::Error("Timezone override is already in effect")
+                 ? Response::ServerError(
+                       "Timezone override is already in effect")
                  : Response::InvalidParams("Invalid timezone id");
     }
   }
 
   timezone_id_override_.Set(timezone_id);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorEmulationAgent::ApplyAcceptLanguageOverride(String* accept_lang) {
@@ -605,7 +608,7 @@ Response InspectorEmulationAgent::AssertPage() {
     return Response::InvalidParams(
         "Can only enable virtual time for pages, not workers");
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorEmulationAgent::Trace(Visitor* visitor) {

third_party/blink/renderer/core/inspector/inspector_io_agent.cc

@@ -25,19 +25,19 @@ Response InspectorIOAgent::resolveBlob(const String& object_id, String* uuid) {
   std::unique_ptr<v8_inspector::StringBuffer> error;
   if (!v8_session_->unwrapObject(&error, ToV8InspectorStringView(object_id),
                                  &value, &context, nullptr))
-    return Response::Error(ToCoreString(std::move(error)));
+    return Response::ServerError(ToCoreString(std::move(error)).Utf8());
 
   if (!V8Blob::HasInstance(value, isolate_))
-    return Response::Error("Object id doesn't reference a Blob");
+    return Response::ServerError("Object id doesn't reference a Blob");
 
   Blob* blob = V8Blob::ToImpl(v8::Local<v8::Object>::Cast(value));
   if (!blob) {
-    return Response::Error(
+    return Response::ServerError(
         "Couldn't convert object with given objectId to Blob");
   }
 
   *uuid = blob->Uuid();
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace blink

third_party/blink/renderer/core/inspector/inspector_layer_tree_agent.cc

@@ -276,7 +276,7 @@ Response InspectorLayerTreeAgent::enable() {
   instrumenting_agents_->AddInspectorLayerTreeAgent(this);
   Document* document = inspected_frames_->Root()->GetDocument();
   if (!document)
-    return Response::Error("The root frame doesn't have document");
+    return Response::ServerError("The root frame doesn't have document");
 
   inspected_frames_->Root()->View()->UpdateAllLifecyclePhases(
       DocumentUpdateReason::kInspector);
@@ -284,13 +284,13 @@ Response InspectorLayerTreeAgent::enable() {
   LayerTreePainted();
   LayerTreeDidChange();
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLayerTreeAgent::disable() {
   instrumenting_agents_->RemoveInspectorLayerTreeAgent(this);
   snapshot_by_id_.clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorLayerTreeAgent::LayerTreeDidChange() {
@@ -365,12 +365,12 @@ Response InspectorLayerTreeAgent::LayerById(const String& layer_id,
   bool ok;
   int id = layer_id.ToInt(&ok);
   if (!ok)
-    return Response::Error("Invalid layer id");
+    return Response::ServerError("Invalid layer id");
 
   result = FindLayerById(RootLayer(), id);
   if (!result)
-    return Response::Error("No layer matching given id found");
-  return Response::OK();
+    return Response::ServerError("No layer matching given id found");
+  return Response::Success();
 }
 
 Response InspectorLayerTreeAgent::compositingReasons(
@@ -379,7 +379,7 @@ Response InspectorLayerTreeAgent::compositingReasons(
     std::unique_ptr<Array<String>>* compositing_reason_ids) {
   const cc::Layer* layer = nullptr;
   Response response = LayerById(layer_id, layer);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   *compositing_reasons = std::make_unique<protocol::Array<String>>();
   *compositing_reason_ids = std::make_unique<protocol::Array<String>>();
@@ -394,7 +394,7 @@ Response InspectorLayerTreeAgent::compositingReasons(
     }
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLayerTreeAgent::makeSnapshot(const String& layer_id,
@@ -408,7 +408,7 @@ Response InspectorLayerTreeAgent::makeSnapshot(const String& layer_id,
                                                       ->GetDocument()
                                                       ->Lifecycle()
                                                       .LifecyclePostponed())
-    return Response::Error("Layer does not draw content");
+    return Response::ServerError("Layer does not draw content");
 
   inspected_frames_->Root()->View()->UpdateAllLifecyclePhases(
       DocumentUpdateReason::kInspector);
@@ -417,29 +417,29 @@ Response InspectorLayerTreeAgent::makeSnapshot(const String& layer_id,
 
   const cc::Layer* layer = nullptr;
   Response response = LayerById(layer_id, layer);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   if (!layer->DrawsContent())
-    return Response::Error("Layer does not draw content");
+    return Response::ServerError("Layer does not draw content");
 
   auto picture = layer->GetPicture();
   if (!picture)
-    return Response::Error("Layer does not produce picture");
+    return Response::ServerError("Layer does not produce picture");
 
   auto snapshot = base::MakeRefCounted<PictureSnapshot>(std::move(picture));
   *snapshot_id = String::Number(++last_snapshot_id_);
   bool new_entry = snapshot_by_id_.insert(*snapshot_id, snapshot).is_new_entry;
   DCHECK(new_entry);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLayerTreeAgent::loadSnapshot(
     std::unique_ptr<Array<protocol::LayerTree::PictureTile>> tiles,
     String* snapshot_id) {
   if (tiles->empty())
-    return Response::Error("Invalid argument, no tiles provided");
+    return Response::ServerError("Invalid argument, no tiles provided");
   if (tiles->size() > UINT_MAX)
-    return Response::Error("Invalid argument, too many tiles provided");
+    return Response::ServerError("Invalid argument, too many tiles provided");
   wtf_size_t tiles_length = static_cast<wtf_size_t>(tiles->size());
   Vector<scoped_refptr<PictureSnapshot::TilePictureStream>> decoded_tiles;
   decoded_tiles.Grow(tiles_length);
@@ -454,22 +454,22 @@ Response InspectorLayerTreeAgent::loadSnapshot(
   scoped_refptr<PictureSnapshot> snapshot =
       PictureSnapshot::Load(decoded_tiles);
   if (!snapshot)
-    return Response::Error("Invalid snapshot format");
+    return Response::ServerError("Invalid snapshot format");
   if (snapshot->IsEmpty())
-    return Response::Error("Empty snapshot");
+    return Response::ServerError("Empty snapshot");
 
   *snapshot_id = String::Number(++last_snapshot_id_);
   bool new_entry = snapshot_by_id_.insert(*snapshot_id, snapshot).is_new_entry;
   DCHECK(new_entry);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLayerTreeAgent::releaseSnapshot(const String& snapshot_id) {
   SnapshotById::iterator it = snapshot_by_id_.find(snapshot_id);
   if (it == snapshot_by_id_.end())
-    return Response::Error("Snapshot not found");
+    return Response::ServerError("Snapshot not found");
   snapshot_by_id_.erase(it);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLayerTreeAgent::GetSnapshotById(
@@ -477,9 +477,9 @@ Response InspectorLayerTreeAgent::GetSnapshotById(
     const PictureSnapshot*& result) {
   SnapshotById::iterator it = snapshot_by_id_.find(snapshot_id);
   if (it == snapshot_by_id_.end())
-    return Response::Error("Snapshot not found");
+    return Response::ServerError("Snapshot not found");
   result = it->value.get();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLayerTreeAgent::replaySnapshot(const String& snapshot_id,
@@ -489,14 +489,14 @@ Response InspectorLayerTreeAgent::replaySnapshot(const String& snapshot_id,
                                                  String* data_url) {
   const PictureSnapshot* snapshot = nullptr;
   Response response = GetSnapshotById(snapshot_id, snapshot);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   auto png_data = snapshot->Replay(from_step.fromMaybe(0), to_step.fromMaybe(0),
                                    scale.fromMaybe(1.0));
   if (png_data.IsEmpty())
-    return Response::Error("Image encoding failed");
+    return Response::ServerError("Image encoding failed");
   *data_url = "data:image/png;base64," + Base64Encode(png_data);
-  return Response::OK();
+  return Response::Success();
 }
 
 static void ParseRect(protocol::DOM::Rect* object, FloatRect* rect) {
@@ -512,7 +512,7 @@ Response InspectorLayerTreeAgent::profileSnapshot(
     std::unique_ptr<protocol::Array<protocol::Array<double>>>* out_timings) {
   const PictureSnapshot* snapshot = nullptr;
   Response response = GetSnapshotById(snapshot_id, snapshot);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   FloatRect rect;
   if (clip_rect.isJust())
@@ -528,7 +528,7 @@ Response InspectorLayerTreeAgent::profileSnapshot(
       out_row->emplace_back(delta.InSecondsF());
     (*out_timings)->emplace_back(std::move(out_row));
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLayerTreeAgent::snapshotCommandLog(
@@ -536,7 +536,7 @@ Response InspectorLayerTreeAgent::snapshotCommandLog(
     std::unique_ptr<Array<protocol::DictionaryValue>>* command_log) {
   const PictureSnapshot* snapshot = nullptr;
   Response response = GetSnapshotById(snapshot_id, snapshot);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   protocol::ErrorSupport errors;
   const String& json = snapshot->SnapshotCommandLog()->ToJSONString();
@@ -557,9 +557,8 @@ Response InspectorLayerTreeAgent::snapshotCommandLog(
                                                              &errors);
   auto err = errors.Errors();
   if (err.empty())
-    return Response::OK();
-  return Response::Error(
-      protocol::StringUtil::fromUTF8(err.data(), err.size()));
+    return Response::Success();
+  return Response::ServerError(std::string(err.begin(), err.end()));
 }
 
 }  // namespace blink

third_party/blink/renderer/core/inspector/inspector_log_agent.cc

@@ -183,24 +183,24 @@ void InspectorLogAgent::InnerEnable() {
 
 Response InspectorLogAgent::enable() {
   if (enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Set(true);
   InnerEnable();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLogAgent::disable() {
   if (!enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Clear();
   stopViolationsReport();
   instrumenting_agents_->RemoveInspectorLogAgent(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLogAgent::clear() {
   storage_->Clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 static PerformanceMonitor::Violation ParseViolation(const String& name) {
@@ -224,9 +224,11 @@ static PerformanceMonitor::Violation ParseViolation(const String& name) {
 Response InspectorLogAgent::startViolationsReport(
     std::unique_ptr<protocol::Array<ViolationSetting>> settings) {
   if (!enabled_.Get())
-    return Response::Error("Log is not enabled");
-  if (!performance_monitor_)
-    return Response::Error("Violations are not supported for this target");
+    return Response::ServerError("Log is not enabled");
+  if (!performance_monitor_) {
+    return Response::ServerError(
+        "Violations are not supported for this target");
+  }
   performance_monitor_->UnsubscribeAll(this);
   violation_thresholds_.Clear();
   for (const std::unique_ptr<ViolationSetting>& setting : *settings) {
@@ -239,15 +241,17 @@ Response InspectorLogAgent::startViolationsReport(
         violation, base::TimeDelta::FromMillisecondsD(threshold), this);
     violation_thresholds_.Set(name, threshold);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorLogAgent::stopViolationsReport() {
   violation_thresholds_.Clear();
-  if (!performance_monitor_)
-    return Response::Error("Violations are not supported for this target");
+  if (!performance_monitor_) {
+    return Response::ServerError(
+        "Violations are not supported for this target");
+  }
   performance_monitor_->UnsubscribeAll(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorLogAgent::ReportLongLayout(base::TimeDelta duration) {

third_party/blink/renderer/core/inspector/inspector_media_agent.cc

@@ -72,18 +72,18 @@ void InspectorMediaAgent::RegisterAgent() {
 
 protocol::Response InspectorMediaAgent::enable() {
   if (enabled_.Get())
-    return protocol::Response::OK();
+    return protocol::Response::Success();
   enabled_.Set(true);
   RegisterAgent();
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 protocol::Response InspectorMediaAgent::disable() {
   if (!enabled_.Get())
-    return protocol::Response::OK();
+    return protocol::Response::Success();
   enabled_.Clear();
   instrumenting_agents_->RemoveInspectorMediaAgent(this);
-  return protocol::Response::OK();
+  return protocol::Response::Success();
 }
 
 void InspectorMediaAgent::PlayerPropertiesChanged(

third_party/blink/renderer/core/inspector/inspector_memory_agent.cc

@@ -63,7 +63,7 @@ Response InspectorMemoryAgent::getDOMCounters(int* documents,
   *nodes = InstanceCounters::CounterValue(InstanceCounters::kNodeCounter);
   *js_event_listeners =
       InstanceCounters::CounterValue(InstanceCounters::kJSEventListenerCounter);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorMemoryAgent::forciblyPurgeJavaScriptMemory() {
@@ -78,7 +78,7 @@ Response InspectorMemoryAgent::forciblyPurgeJavaScriptMemory() {
   }
   V8PerIsolateData::MainThreadIsolate()->MemoryPressureNotification(
       v8::MemoryPressureLevel::kCritical);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorMemoryAgent::Trace(Visitor* visitor) {
@@ -98,33 +98,33 @@ Response InspectorMemoryAgent::startSampling(
   int interval =
       in_sampling_interval.fromMaybe(kDefaultNativeMemorySamplingInterval);
   if (interval <= 0)
-    return Response::Error("Invalid sampling rate.");
+    return Response::ServerError("Invalid sampling rate.");
   base::SamplingHeapProfiler::Get()->SetSamplingInterval(interval);
   sampling_profile_interval_.Set(interval);
   if (in_suppressRandomness.fromMaybe(false))
     base::PoissonAllocationSampler::Get()->SuppressRandomnessForTest(true);
   profile_id_ = base::SamplingHeapProfiler::Get()->Start();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorMemoryAgent::stopSampling() {
   if (sampling_profile_interval_.Get() == 0)
-    return Response::Error("Sampling profiler is not started.");
+    return Response::ServerError("Sampling profiler is not started.");
   base::SamplingHeapProfiler::Get()->Stop();
   sampling_profile_interval_.Clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorMemoryAgent::getAllTimeSamplingProfile(
     std::unique_ptr<protocol::Memory::SamplingProfile>* out_profile) {
   *out_profile = GetSamplingProfileById(0);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorMemoryAgent::getSamplingProfile(
     std::unique_ptr<protocol::Memory::SamplingProfile>* out_profile) {
   *out_profile = GetSamplingProfileById(profile_id_);
-  return Response::OK();
+  return Response::Success();
 }
 
 std::unique_ptr<protocol::Memory::SamplingProfile>

third_party/blink/renderer/core/inspector/inspector_network_agent.cc

@@ -220,7 +220,7 @@ static void ResponseBodyFileReaderLoaderDone(
     std::unique_ptr<GetResponseBodyCallback> callback,
     scoped_refptr<SharedBuffer> raw_data) {
   if (!raw_data) {
-    callback->sendFailure(Response::Error("Couldn't read BLOB"));
+    callback->sendFailure(Response::ServerError("Couldn't read BLOB"));
     return;
   }
   String result;
@@ -229,7 +229,7 @@ static void ResponseBodyFileReaderLoaderDone(
           raw_data, mime_type, text_encoding_name, &result, &base64_encoded)) {
     callback->sendSuccess(result, base64_encoded);
   } else {
-    callback->sendFailure(Response::Error("Couldn't encode data"));
+    callback->sendFailure(Response::ServerError("Couldn't encode data"));
   }
 }
 
@@ -1384,7 +1384,7 @@ Response InspectorNetworkAgent::enable(Maybe<int> total_buffer_size,
       resource_buffer_size.fromMaybe(kDefaultResourceBufferSize));
   max_post_data_size_.Set(max_post_data_size.fromMaybe(0));
   Enable();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorNetworkAgent::Enable() {
@@ -1403,7 +1403,7 @@ Response InspectorNetworkAgent::disable() {
   instrumenting_agents_->RemoveInspectorNetworkAgent(this);
   agent_state_.ClearAllFields();
   resources_data_->Clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::setExtraHTTPHeaders(
@@ -1416,7 +1416,7 @@ Response InspectorNetworkAgent::setExtraHTTPHeaders(
     if (entry.second && entry.second->asString(&value))
       extra_request_headers_.Set(entry.first, value);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 bool InspectorNetworkAgent::CanGetResponseBodyBlob(const String& request_id) {
@@ -1463,7 +1463,7 @@ void InspectorNetworkAgent::getResponseBody(
   String content;
   bool base64_encoded;
   Response response = GetResponseBody(request_id, &content, &base64_encoded);
-  if (response.isSuccess()) {
+  if (response.IsSuccess()) {
     callback->sendSuccess(content, base64_encoded);
   } else {
     callback->sendFailure(response);
@@ -1475,7 +1475,7 @@ Response InspectorNetworkAgent::setBlockedURLs(
   blocked_urls_.Clear();
   for (const String& url : *urls)
     blocked_urls_.Set(url, true);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::replayXHR(const String& request_id) {
@@ -1484,12 +1484,12 @@ Response InspectorNetworkAgent::replayXHR(const String& request_id) {
   XHRReplayData* xhr_replay_data = resources_data_->XhrReplayData(request_id);
   auto* data = resources_data_->Data(request_id);
   if (!xhr_replay_data || !data)
-    return Response::Error("Given id does not correspond to XHR");
+    return Response::ServerError("Given id does not correspond to XHR");
 
   ExecutionContext* execution_context = xhr_replay_data->GetExecutionContext();
   if (!execution_context || execution_context->IsContextDestroyed()) {
     resources_data_->SetXHRReplayData(request_id, nullptr);
-    return Response::Error("Document is already detached");
+    return Response::ServerError("Document is already detached");
   }
 
   XMLHttpRequest* xhr = XMLHttpRequest::Create(execution_context);
@@ -1508,17 +1508,17 @@ Response InspectorNetworkAgent::replayXHR(const String& request_id) {
                                  IGNORE_EXCEPTION_FOR_TESTING);
 
   replay_xhrs_.insert(xhr);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::canClearBrowserCache(bool* result) {
   *result = true;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::canClearBrowserCookies(bool* result) {
   *result = true;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::emulateNetworkConditions(
@@ -1528,13 +1528,13 @@ Response InspectorNetworkAgent::emulateNetworkConditions(
     double upload_throughput,
     Maybe<String> connection_type) {
   if (!IsMainThread())
-    return Response::Error("Not supported");
+    return Response::ServerError("Not supported");
 
   WebConnectionType type = kWebConnectionTypeUnknown;
   if (connection_type.isJust()) {
     type = ToWebConnectionType(connection_type.fromJust());
     if (type == kWebConnectionTypeUnknown)
-      return Response::Error("Unknown connection type");
+      return Response::ServerError("Unknown connection type");
   }
   // TODO(dgozman): networkStateNotifier is per-process. It would be nice to
   // have per-frame override instead.
@@ -1545,7 +1545,7 @@ Response InspectorNetworkAgent::emulateNetworkConditions(
   } else {
     GetNetworkStateNotifier().ClearOverride();
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::setCacheDisabled(bool cache_disabled) {
@@ -1555,18 +1555,18 @@ Response InspectorNetworkAgent::setCacheDisabled(bool cache_disabled) {
   cache_disabled_.Set(cache_disabled);
   if (cache_disabled && IsMainThread())
     GetMemoryCache()->EvictResources();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::setBypassServiceWorker(bool bypass) {
   bypass_service_worker_.Set(bypass);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::setDataSizeLimitsForTest(int max_total,
                                                          int max_resource) {
   resources_data_->SetResourcesDataSizeLimits(max_total, max_resource);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorNetworkAgent::getCertificate(
@@ -1585,10 +1585,10 @@ Response InspectorNetworkAgent::getCertificate(
             ->emplace_back(
                 Base64Encode(base::as_bytes(base::make_span(cert.Latin1()))));
       }
-      return Response::OK();
+      return Response::Success();
     }
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorNetworkAgent::DidCommitLoad(LocalFrame* frame,
@@ -1626,17 +1626,18 @@ Response InspectorNetworkAgent::GetResponseBody(const String& request_id,
   NetworkResourcesData::ResourceData const* resource_data =
       resources_data_->Data(request_id);
   if (!resource_data) {
-    return Response::Error("No resource with given identifier found");
+    return Response::ServerError("No resource with given identifier found");
   }
 
   if (resource_data->HasContent()) {
     *content = resource_data->Content();
     *base64_encoded = resource_data->Base64Encoded();
-    return Response::OK();
+    return Response::Success();
   }
 
   if (resource_data->IsContentEvicted()) {
-    return Response::Error("Request content was evicted from inspector cache");
+    return Response::ServerError(
+        "Request content was evicted from inspector cache");
   }
 
   if (resource_data->Buffer() && !resource_data->TextEncodingName().IsNull()) {
@@ -1644,16 +1645,17 @@ Response InspectorNetworkAgent::GetResponseBody(const String& request_id,
         resource_data->Buffer(), resource_data->MimeType(),
         resource_data->TextEncodingName(), content, base64_encoded);
     DCHECK(success);
-    return Response::OK();
+    return Response::Success();
   }
 
   if (resource_data->CachedResource() &&
       InspectorPageAgent::CachedResourceContent(resource_data->CachedResource(),
                                                 content, base64_encoded)) {
-    return Response::OK();
+    return Response::Success();
   }
 
-  return Response::Error("No data found for resource with given identifier");
+  return Response::ServerError(
+      "No data found for resource with given identifier");
 }
 
 Response InspectorNetworkAgent::searchInResponseBody(
@@ -1667,7 +1669,7 @@ Response InspectorNetworkAgent::searchInResponseBody(
   String content;
   bool base64_encoded;
   Response response = GetResponseBody(request_id, &content, &base64_encoded);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   auto results = v8_session_->searchInTextByLines(
@@ -1676,7 +1678,7 @@ Response InspectorNetworkAgent::searchInResponseBody(
   *matches = std::make_unique<
       protocol::Array<v8_inspector::protocol::Debugger::API::SearchMatch>>(
       std::move(results));
-  return Response::OK();
+  return Response::Success();
 }
 
 bool InspectorNetworkAgent::FetchResourceContent(Document* document,
@@ -1766,13 +1768,13 @@ void InspectorNetworkAgent::getRequestPostData(
       resources_data_->Data(request_id);
   if (!resource_data) {
     callback->sendFailure(
-        Response::Error("No resource with given id was found"));
+        Response::ServerError("No resource with given id was found"));
     return;
   }
   scoped_refptr<EncodedFormData> post_data = resource_data->PostData();
   if (!post_data || post_data->IsEmpty()) {
     callback->sendFailure(
-        Response::Error("No post data available for the request"));
+        Response::ServerError("No post data available for the request"));
     return;
   }
   ExecutionContext* context = GetTargetExecutionContext();

third_party/blink/renderer/core/inspector/inspector_overlay_agent.cc

@@ -380,7 +380,7 @@ void InspectorOverlayAgent::Dispose() {
 
 Response InspectorOverlayAgent::enable() {
   if (!dom_agent_->Enabled())
-    return Response::Error("DOM should be enabled first");
+    return Response::ServerError("DOM should be enabled first");
   enabled_.Set(true);
   if (backend_node_id_to_inspect_) {
     GetFrontend()->inspectNodeRequested(
@@ -388,7 +388,7 @@ Response InspectorOverlayAgent::enable() {
   }
   backend_node_id_to_inspect_ = 0;
   SetNeedsUnbufferedInput(true);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::disable() {
@@ -417,20 +417,20 @@ Response InspectorOverlayAgent::disable() {
   frame_resource_name_ = 0;
   PickTheRightTool();
   SetNeedsUnbufferedInput(false);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setShowAdHighlights(bool show) {
   show_ad_highlights_.Set(show);
   frame_impl_->ViewImpl()->GetPage()->GetSettings().SetHighlightAds(show);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setShowDebugBorders(bool show) {
   show_debug_borders_.Set(show);
   if (show) {
     Response response = CompositingEnabled();
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
   WebFrameWidget* widget = frame_impl_->LocalRoot()->FrameWidget();
@@ -445,14 +445,14 @@ Response InspectorOverlayAgent::setShowDebugBorders(bool show) {
       debug_state.show_debug_borders.reset();
     widget_impl->SetLayerTreeDebugState(debug_state);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setShowFPSCounter(bool show) {
   show_fps_counter_.Set(show);
   if (show) {
     Response response = CompositingEnabled();
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
   WebFrameWidget* widget = frame_impl_->LocalRoot()->FrameWidget();
@@ -464,14 +464,14 @@ Response InspectorOverlayAgent::setShowFPSCounter(bool show) {
     debug_state.show_fps_counter = show;
     widget_impl->SetLayerTreeDebugState(debug_state);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setShowPaintRects(bool show) {
   show_paint_rects_.Set(show);
   if (show) {
     Response response = CompositingEnabled();
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
   WebFrameWidget* widget = frame_impl_->LocalRoot()->FrameWidget();
@@ -485,14 +485,14 @@ Response InspectorOverlayAgent::setShowPaintRects(bool show) {
   }
   if (!show && frame_impl_->GetFrameView())
     frame_impl_->GetFrameView()->Invalidate();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setShowLayoutShiftRegions(bool show) {
   show_layout_shift_regions_.Set(show);
   if (show) {
     Response response = CompositingEnabled();
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
   WebFrameWidget* widget = frame_impl_->LocalRoot()->FrameWidget();
@@ -507,14 +507,14 @@ Response InspectorOverlayAgent::setShowLayoutShiftRegions(bool show) {
 
   if (!show && frame_impl_->GetFrameView())
     frame_impl_->GetFrameView()->Invalidate();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setShowScrollBottleneckRects(bool show) {
   show_scroll_bottleneck_rects_.Set(show);
   if (show) {
     Response response = CompositingEnabled();
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
   WebFrameWidget* widget = frame_impl_->LocalRoot()->FrameWidget();
@@ -530,14 +530,14 @@ Response InspectorOverlayAgent::setShowScrollBottleneckRects(bool show) {
     widget_impl->SetLayerTreeDebugState(debug_state);
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setShowHitTestBorders(bool show) {
   show_hit_test_borders_.Set(show);
   if (show) {
     Response response = CompositingEnabled();
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
   }
   WebFrameWidget* widget = frame_impl_->LocalRoot()->FrameWidget();
@@ -549,19 +549,19 @@ Response InspectorOverlayAgent::setShowHitTestBorders(bool show) {
     debug_state.show_hit_test_borders = show;
     widget_impl->SetLayerTreeDebugState(debug_state);
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setShowViewportSizeOnResize(bool show) {
   show_size_on_resize_.Set(show);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::setPausedInDebuggerMessage(
     Maybe<String> message) {
   paused_in_debugger_message_.Set(message.fromMaybe(String()));
   PickTheRightTool();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::highlightRect(
@@ -576,7 +576,7 @@ Response InspectorOverlayAgent::highlightRect(
   SetInspectTool(MakeGarbageCollected<QuadHighlightTool>(
       std::move(quad), InspectorDOMAgent::ParseColor(color.fromMaybe(nullptr)),
       InspectorDOMAgent::ParseColor(outline_color.fromMaybe(nullptr))));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::highlightQuad(
@@ -585,11 +585,11 @@ Response InspectorOverlayAgent::highlightQuad(
     Maybe<protocol::DOM::RGBA> outline_color) {
   std::unique_ptr<FloatQuad> quad = std::make_unique<FloatQuad>();
   if (!ParseQuad(std::move(quad_array), quad.get()))
-    return Response::Error("Invalid Quad format");
+    return Response::ServerError("Invalid Quad format");
   SetInspectTool(MakeGarbageCollected<QuadHighlightTool>(
       std::move(quad), InspectorDOMAgent::ParseColor(color.fromMaybe(nullptr)),
       InspectorDOMAgent::ParseColor(outline_color.fromMaybe(nullptr))));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::highlightNode(
@@ -602,18 +602,18 @@ Response InspectorOverlayAgent::highlightNode(
   Node* node = nullptr;
   Response response =
       dom_agent_->AssertNode(node_id, backend_node_id, object_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   std::unique_ptr<InspectorHighlightConfig> highlight_config;
   response = HighlightConfigFromInspectorObject(
       std::move(highlight_inspector_object), &highlight_config);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   SetInspectTool(MakeGarbageCollected<NodeHighlightTool>(
       node, selector_list.fromMaybe(String()), std::move(highlight_config)));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::highlightFrame(
@@ -624,7 +624,7 @@ Response InspectorOverlayAgent::highlightFrame(
       IdentifiersFactory::FrameById(inspected_frames_, frame_id);
   // FIXME: Inspector doesn't currently work cross process.
   if (!frame)
-    return Response::Error("Invalid frame id");
+    return Response::ServerError("Invalid frame id");
   if (frame->DeprecatedLocalOwner()) {
     std::unique_ptr<InspectorHighlightConfig> highlight_config =
         std::make_unique<InspectorHighlightConfig>();
@@ -639,13 +639,13 @@ Response InspectorOverlayAgent::highlightFrame(
   } else {
     PickTheRightTool();
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::hideHighlight() {
   if (inspect_tool_ && inspect_tool_->HideOnHideHighlight())
     PickTheRightTool();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorOverlayAgent::getHighlightObjectForTest(
@@ -655,7 +655,7 @@ Response InspectorOverlayAgent::getHighlightObjectForTest(
     std::unique_ptr<protocol::DictionaryValue>* result) {
   Node* node = nullptr;
   Response response = dom_agent_->AssertNode(node_id, node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   bool is_locked_ancestor = false;
 
@@ -674,7 +674,7 @@ Response InspectorOverlayAgent::getHighlightObjectForTest(
                                include_distance.fromMaybe(false),
                                is_locked_ancestor);
   *result = highlight.AsProtocolValue();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorOverlayAgent::UpdatePrePaint() {
@@ -1083,8 +1083,8 @@ Response InspectorOverlayAgent::CompositingEnabled() {
                           ->GetPage()
                           ->GetSettings()
                           .GetAcceleratedCompositingEnabled())
-    return Response::Error("Compositing mode is not supported");
-  return Response::OK();
+    return Response::ServerError("Compositing mode is not supported");
+  return Response::Success();
 }
 
 bool InspectorOverlayAgent::InSomeInspectMode() {
@@ -1119,8 +1119,8 @@ Response InspectorOverlayAgent::setInspectMode(
       mode != protocol::Overlay::InspectModeEnum::SearchForUAShadowDOM &&
       mode != protocol::Overlay::InspectModeEnum::CaptureAreaScreenshot &&
       mode != protocol::Overlay::InspectModeEnum::ShowDistances) {
-    return Response::Error(
-        String("Unknown mode \"" + mode + "\" was provided."));
+    return Response::ServerError(
+        String("Unknown mode \"" + mode + "\" was provided.").Utf8());
   }
 
   std::vector<uint8_t> serialized_config;
@@ -1130,13 +1130,13 @@ Response InspectorOverlayAgent::setInspectMode(
   std::unique_ptr<InspectorHighlightConfig> config;
   Response response = HighlightConfigFromInspectorObject(
       std::move(highlight_inspector_object), &config);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   inspect_mode_.Set(mode);
   inspect_mode_protocol_config_.Set(serialized_config);
 
   PickTheRightTool();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorOverlayAgent::PickTheRightTool() {
@@ -1196,13 +1196,13 @@ Response InspectorOverlayAgent::HighlightConfigFromInspectorObject(
     Maybe<protocol::Overlay::HighlightConfig> highlight_inspector_object,
     std::unique_ptr<InspectorHighlightConfig>* out_config) {
   if (!highlight_inspector_object.isJust()) {
-    return Response::Error(
+    return Response::ServerError(
         "Internal error: highlight configuration parameter is missing");
   }
   protocol::Overlay::HighlightConfig* config =
       highlight_inspector_object.fromJust();
   *out_config = InspectorOverlayAgent::ToHighlightConfig(config);
-  return Response::OK();
+  return Response::Success();
 }
 
 // static

third_party/blink/renderer/core/inspector/inspector_page_agent.cc

@@ -521,7 +521,7 @@ void InspectorPageAgent::Restore() {
 Response InspectorPageAgent::enable() {
   enabled_.Set(true);
   instrumenting_agents_->AddInspectorPageAgent(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::disable() {
@@ -534,7 +534,7 @@ Response InspectorPageAgent::disable() {
 
   stopScreencast();
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::addScriptToEvaluateOnNewDocument(
@@ -554,16 +554,16 @@ Response InspectorPageAgent::addScriptToEvaluateOnNewDocument(
 
   scripts_to_evaluate_on_load_.Set(*identifier, source);
   worlds_to_evaluate_on_load_.Set(*identifier, world_name.fromMaybe(""));
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::removeScriptToEvaluateOnNewDocument(
     const String& identifier) {
   if (scripts_to_evaluate_on_load_.Get(identifier).IsNull())
-    return Response::Error("Script not found");
+    return Response::ServerError("Script not found");
   scripts_to_evaluate_on_load_.Clear(identifier);
   worlds_to_evaluate_on_load_.Clear(identifier);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::addScriptToEvaluateOnLoad(const String& source,
@@ -580,7 +580,7 @@ Response InspectorPageAgent::removeScriptToEvaluateOnLoad(
 Response InspectorPageAgent::setLifecycleEventsEnabled(bool enabled) {
   lifecycle_events_enabled_.Set(enabled);
   if (!enabled)
-    return Response::OK();
+    return Response::Success();
 
   for (LocalFrame* frame : *inspected_frames_) {
     Document* document = frame->GetDocument();
@@ -623,11 +623,11 @@ Response InspectorPageAgent::setLifecycleEventsEnabled(bool enabled) {
     }
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::setAdBlockingEnabled(bool enable) {
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::reload(
@@ -636,11 +636,11 @@ Response InspectorPageAgent::reload(
   pending_script_to_evaluate_on_load_once_ =
       optional_script_to_evaluate_on_load.fromMaybe("");
   v8_session_->setSkipAllPauses(true);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::stopLoading() {
-  return Response::OK();
+  return Response::Success();
 }
 
 static void CachedResourcesForDocument(Document* document,
@@ -696,13 +696,13 @@ static HeapVector<Member<Resource>> CachedResourcesForFrame(LocalFrame* frame,
 Response InspectorPageAgent::getResourceTree(
     std::unique_ptr<protocol::Page::FrameResourceTree>* object) {
   *object = BuildObjectForResourceTree(inspected_frames_->Root());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::getFrameTree(
     std::unique_ptr<protocol::Page::FrameTree>* object) {
   *object = BuildObjectForFrameTree(inspected_frames_->Root());
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorPageAgent::GetResourceContentAfterResourcesContentLoaded(
@@ -712,17 +712,19 @@ void InspectorPageAgent::GetResourceContentAfterResourcesContentLoaded(
   LocalFrame* frame =
       IdentifiersFactory::FrameById(inspected_frames_, frame_id);
   if (!frame) {
-    callback->sendFailure(Response::Error("No frame for given id found"));
+    callback->sendFailure(Response::ServerError("No frame for given id found"));
     return;
   }
   String content;
   bool base64_encoded;
   if (InspectorPageAgent::CachedResourceContent(
           CachedResource(frame, KURL(url), inspector_resource_content_loader_),
-          &content, &base64_encoded))
+          &content, &base64_encoded)) {
     callback->sendSuccess(content, base64_encoded);
-  else
-    callback->sendFailure(Response::Error("No resource with given URL found"));
+  } else {
+    callback->sendFailure(
+        Response::ServerError("No resource with given URL found"));
+  }
 }
 
 void InspectorPageAgent::getResourceContent(
@@ -730,7 +732,7 @@ void InspectorPageAgent::getResourceContent(
     const String& url,
     std::unique_ptr<GetResourceContentCallback> callback) {
   if (!enabled_.Get()) {
-    callback->sendFailure(Response::Error("Agent is not enabled."));
+    callback->sendFailure(Response::ServerError("Agent is not enabled."));
     return;
   }
   inspector_resource_content_loader_->EnsureResourcesContentLoaded(
@@ -751,7 +753,7 @@ void InspectorPageAgent::SearchContentAfterResourcesContentLoaded(
   LocalFrame* frame =
       IdentifiersFactory::FrameById(inspected_frames_, frame_id);
   if (!frame) {
-    callback->sendFailure(Response::Error("No frame for given id found"));
+    callback->sendFailure(Response::ServerError("No frame for given id found"));
     return;
   }
   String content;
@@ -759,7 +761,8 @@ void InspectorPageAgent::SearchContentAfterResourcesContentLoaded(
   if (!InspectorPageAgent::CachedResourceContent(
           CachedResource(frame, KURL(url), inspector_resource_content_loader_),
           &content, &base64_encoded)) {
-    callback->sendFailure(Response::Error("No resource with given URL found"));
+    callback->sendFailure(
+        Response::ServerError("No resource with given URL found"));
     return;
   }
 
@@ -780,7 +783,7 @@ void InspectorPageAgent::searchInResource(
     Maybe<bool> optional_is_regex,
     std::unique_ptr<SearchInResourceCallback> callback) {
   if (!enabled_.Get()) {
-    callback->sendFailure(Response::Error("Agent is not enabled."));
+    callback->sendFailure(Response::ServerError("Agent is not enabled."));
     return;
   }
   inspector_resource_content_loader_->EnsureResourcesContentLoaded(
@@ -796,7 +799,7 @@ Response InspectorPageAgent::setBypassCSP(bool enabled) {
   LocalFrame* frame = inspected_frames_->Root();
   frame->GetSettings()->SetBypassCSP(enabled);
   bypass_csp_enabled_.Set(enabled);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::setDocumentContent(const String& frame_id,
@@ -804,13 +807,13 @@ Response InspectorPageAgent::setDocumentContent(const String& frame_id,
   LocalFrame* frame =
       IdentifiersFactory::FrameById(inspected_frames_, frame_id);
   if (!frame)
-    return Response::Error("No frame for given id found");
+    return Response::ServerError("No frame for given id found");
 
   Document* document = frame->GetDocument();
   if (!document)
-    return Response::Error("No Document instance to set HTML for");
+    return Response::ServerError("No Document instance to set HTML for");
   document->SetContent(html);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorPageAgent::DidNavigateWithinDocument(LocalFrame* frame) {
@@ -1158,12 +1161,12 @@ Response InspectorPageAgent::startScreencast(Maybe<String> format,
                                              Maybe<int> max_height,
                                              Maybe<int> every_nth_frame) {
   screencast_enabled_.Set(true);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::stopScreencast() {
   screencast_enabled_.Set(false);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::getLayoutMetrics(
@@ -1220,7 +1223,7 @@ Response InspectorPageAgent::getLayoutMetrics(
                              .setScale(scale)
                              .setZoom(page_zoom_factor)
                              .build();
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response InspectorPageAgent::createIsolatedWorld(
@@ -1231,19 +1234,19 @@ protocol::Response InspectorPageAgent::createIsolatedWorld(
   LocalFrame* frame =
       IdentifiersFactory::FrameById(inspected_frames_, frame_id);
   if (!frame)
-    return Response::Error("No frame for given id found");
+    return Response::ServerError("No frame for given id found");
 
   scoped_refptr<DOMWrapperWorld> world = EnsureDOMWrapperWorld(
       frame, world_name.fromMaybe(""), grant_universal_access.fromMaybe(false));
   if (!world)
-    return Response::Error("Could not create isolated world");
+    return Response::ServerError("Could not create isolated world");
 
   LocalWindowProxy* isolated_world_window_proxy =
       frame->GetScriptController().WindowProxy(*world);
   v8::HandleScope handle_scope(V8PerIsolateData::MainThreadIsolate());
   *execution_context_id = v8_inspector::V8ContextInfo::executionContextId(
       isolated_world_window_proxy->ContextIfInitialized());
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::setFontFamilies(
@@ -1285,7 +1288,7 @@ Response InspectorPageAgent::setFontFamilies(
     settings->NotifyGenericFontFamilyChange();
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::setFontSizes(
@@ -1303,7 +1306,7 @@ Response InspectorPageAgent::setFontSizes(
     }
   }
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorPageAgent::ConsumeCompilationCache(
@@ -1365,28 +1368,28 @@ void InspectorPageAgent::FileChooserOpened(LocalFrame* frame,
 
 Response InspectorPageAgent::setProduceCompilationCache(bool enabled) {
   produce_compilation_cache_.Set(enabled);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::addCompilationCache(const String& url,
                                                  const protocol::Binary& data) {
   compilation_cache_.Set(url, data);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::clearCompilationCache() {
   compilation_cache_.clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::waitForDebugger() {
   client_->WaitForDebugger();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::setInterceptFileChooserDialog(bool enabled) {
   intercept_file_chooser_ = enabled;
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorPageAgent::generateTestReport(const String& message,
@@ -1401,7 +1404,7 @@ Response InspectorPageAgent::generateTestReport(const String& message,
   // Send the test report to any ReportingObservers.
   ReportingContext::From(document->ToExecutionContext())->QueueReport(report);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorPageAgent::Trace(Visitor* visitor) {

third_party/blink/renderer/core/inspector/inspector_performance_agent.cc

@@ -68,29 +68,29 @@ protocol::Response InspectorPerformanceAgent::enable(
   String time_domain = optional_time_domain.fromMaybe(TimeDomain::TimeTicks);
   if (enabled_.Get()) {
     if (!HasTimeDomain(time_domain)) {
-      return Response::Error(
+      return Response::ServerError(
           "Cannot change time domain while performance metrics collection is "
           "enabled.");
     }
-    return Response::OK();
+    return Response::Success();
   }
 
   Response response = InnerSetTimeDomain(time_domain);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   enabled_.Set(true);
   InnerEnable();
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response InspectorPerformanceAgent::disable() {
   if (!enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Clear();
   instrumenting_agents_->RemoveInspectorPerformanceAgent(this);
   Thread::Current()->RemoveTaskTimeObserver(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 namespace {
@@ -107,7 +107,7 @@ void AppendMetric(protocol::Array<protocol::Performance::Metric>* container,
 // TODO(crbug.com/1056306): remove this redundant API.
 Response InspectorPerformanceAgent::setTimeDomain(const String& time_domain) {
   if (enabled_.Get()) {
-    return Response::Error(
+    return Response::ServerError(
         "Cannot set time domain while performance metrics collection"
         " is enabled.");
   }
@@ -141,18 +141,20 @@ Response InspectorPerformanceAgent::InnerSetTimeDomain(
 
   if (time_domain == TimeDomain::TimeTicks) {
     use_thread_ticks_.Clear();
-    return Response::OK();
+    return Response::Success();
   }
 
   if (time_domain == TimeDomain::ThreadTicks) {
-    if (!base::ThreadTicks::IsSupported())
-      return Response::Error("Thread time is not supported on this platform.");
+    if (!base::ThreadTicks::IsSupported()) {
+      return Response::ServerError(
+          "Thread time is not supported on this platform.");
+    }
     base::ThreadTicks::WaitUntilInitialized();
     use_thread_ticks_.Set(true);
-    return Response::OK();
+    return Response::Success();
   }
 
-  return Response::Error("Invalid time domain specification.");
+  return Response::ServerError("Invalid time domain specification.");
 }
 
 Response InspectorPerformanceAgent::getMetrics(
@@ -161,7 +163,7 @@ Response InspectorPerformanceAgent::getMetrics(
   if (!enabled_.Get()) {
     *out_result =
         std::make_unique<protocol::Array<protocol::Performance::Metric>>();
-    return Response::OK();
+    return Response::Success();
   }
 
   auto result =
@@ -248,7 +250,7 @@ Response InspectorPerformanceAgent::getMetrics(
   }
 
   *out_result = std::move(result);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorPerformanceAgent::ConsoleTimeStamp(const String& title) {

third_party/blink/renderer/core/inspector/legacy_dom_snapshot_agent.cc

@@ -145,7 +145,7 @@ Response LegacyDOMSnapshotAgent::GetSnapshot(
   computed_styles_map_.reset();
   css_property_filter_.reset();
   paint_order_map_.reset();
-  return Response::OK();
+  return Response::Success();
 }
 
 int LegacyDOMSnapshotAgent::VisitNode(Node* node,

third_party/blink/renderer/core/inspector/v8_inspector_string.h

@@ -39,18 +39,6 @@ class CORE_EXPORT StringUtil {
   STATIC_ONLY(StringUtil);
 
  public:
-  static String substring(const String& s, size_t pos, size_t len) {
-    return s.Substring(static_cast<wtf_size_t>(pos),
-                       static_cast<wtf_size_t>(len));
-  }
-  static size_t find(const String& s, const char* needle) {
-    return s.Find(needle);
-  }
-  static size_t find(const String& s, const String& needle) {
-    return s.Find(needle);
-  }
-  static const size_t kNotFound = WTF::kNotFound;
-
   static String fromUTF8(const uint8_t* data, size_t length) {
     return String::FromUTF8(reinterpret_cast<const char*>(data), length);
   }

third_party/blink/renderer/modules/accessibility/inspector_accessibility_agent.cc

@@ -523,7 +523,7 @@ Response InspectorAccessibilityAgent::getPartialAXTree(
   Node* dom_node = nullptr;
   Response response =
       dom_agent_->AssertNode(dom_node_id, backend_node_id, object_id, dom_node);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   Document& document = dom_node->GetDocument();
@@ -532,7 +532,7 @@ Response InspectorAccessibilityAgent::getPartialAXTree(
       document.Lifecycle());
   LocalFrame* local_frame = document.GetFrame();
   if (!local_frame)
-    return Response::Error("Frame is detached.");
+    return Response::ServerError("Frame is detached.");
   AXContext ax_context(document);
   auto& cache = To<AXObjectCacheImpl>(ax_context.GetAXObjectCache());
 
@@ -542,7 +542,7 @@ Response InspectorAccessibilityAgent::getPartialAXTree(
     (*nodes)->emplace_back(BuildObjectForIgnoredNode(
         dom_node, inspected_ax_object, fetch_relatives.fromMaybe(true), *nodes,
         cache));
-    return Response::OK();
+    return Response::Success();
   } else {
     (*nodes)->emplace_back(
         BuildProtocolAXObject(*inspected_ax_object, inspected_ax_object,
@@ -550,16 +550,16 @@ Response InspectorAccessibilityAgent::getPartialAXTree(
   }
 
   if (!inspected_ax_object)
-    return Response::OK();
+    return Response::Success();
 
   AXObject* parent = inspected_ax_object->ParentObjectUnignored();
   if (!parent)
-    return Response::OK();
+    return Response::Success();
 
   if (fetch_relatives.fromMaybe(true))
     AddAncestors(*parent, inspected_ax_object, *nodes, cache);
 
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorAccessibilityAgent::AddAncestors(
@@ -718,7 +718,7 @@ Response InspectorAccessibilityAgent::getFullAXTree(
     std::unique_ptr<protocol::Array<AXNode>>* nodes) {
   Document* document = inspected_frames_->Root()->GetDocument();
   if (!document)
-    return Response::Error("No document.");
+    return Response::ServerError("No document.");
   if (document->View()->NeedsLayout() || document->NeedsLayoutTreeUpdate())
     document->UpdateStyleAndLayout(DocumentUpdateReason::kInspector);
   *nodes = std::make_unique<protocol::Array<protocol::Accessibility::AXNode>>();
@@ -743,7 +743,7 @@ Response InspectorAccessibilityAgent::getFullAXTree(
     node->setChildIds(std::move(child_ids));
     (*nodes)->emplace_back(std::move(node));
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorAccessibilityAgent::FillCoreProperties(
@@ -853,12 +853,12 @@ void InspectorAccessibilityAgent::EnableAndReset() {
 protocol::Response InspectorAccessibilityAgent::enable() {
   if (!enabled_.Get())
     EnableAndReset();
-  return Response::OK();
+  return Response::Success();
 }
 
 protocol::Response InspectorAccessibilityAgent::disable() {
   if (!enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Set(false);
   context_ = nullptr;
   LocalFrame* frame = inspected_frames_->Root();
@@ -867,7 +867,7 @@ protocol::Response InspectorAccessibilityAgent::disable() {
   it->value.erase(this);
   if (it->value.IsEmpty())
     EnabledAgents().erase(frame);
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorAccessibilityAgent::Restore() {

third_party/blink/renderer/modules/cache_storage/inspector_cache_storage_agent.cc

@@ -79,26 +79,28 @@ ProtocolResponse ParseCacheId(const String& id,
                               String* cache_name) {
   wtf_size_t pipe = id.find('|');
   if (pipe == WTF::kNotFound)
-    return ProtocolResponse::Error("Invalid cache id.");
+    return ProtocolResponse::ServerError("Invalid cache id.");
   *security_origin = id.Substring(0, pipe);
   *cache_name = id.Substring(pipe + 1);
-  return ProtocolResponse::OK();
+  return ProtocolResponse::Success();
 }
 
 ProtocolResponse GetExecutionContext(InspectedFrames* frames,
                                      const String& security_origin,
                                      ExecutionContext** context) {
   LocalFrame* frame = frames->FrameWithSecurityOrigin(security_origin);
-  if (!frame)
-    return ProtocolResponse::Error("No frame with origin " + security_origin);
+  if (!frame) {
+    String msg = "No frame with origin " + security_origin;
+    return ProtocolResponse::ServerError(msg.Utf8());
+  }
 
   blink::Document* document = frame->GetDocument();
   if (!document)
-    return ProtocolResponse::Error("No execution context found");
+    return ProtocolResponse::ServerError("No execution context found");
 
   *context = document->ToExecutionContext();
 
-  return ProtocolResponse::OK();
+  return ProtocolResponse::Success();
 }
 
 ProtocolResponse AssertCacheStorage(
@@ -111,14 +113,14 @@ ProtocolResponse AssertCacheStorage(
 
   // Cache Storage API is restricted to trustworthy origins.
   if (!sec_origin->IsPotentiallyTrustworthy()) {
-    return ProtocolResponse::Error(
-        sec_origin->IsPotentiallyTrustworthyErrorMessage());
+    return ProtocolResponse::ServerError(
+        sec_origin->IsPotentiallyTrustworthyErrorMessage().Utf8());
   }
 
   ExecutionContext* context = nullptr;
   ProtocolResponse response =
       GetExecutionContext(frames, security_origin, &context);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   auto it = caches->find(security_origin);
@@ -133,7 +135,7 @@ ProtocolResponse AssertCacheStorage(
     *result = it->value.get();
   }
 
-  return ProtocolResponse::OK();
+  return ProtocolResponse::Success();
 }
 
 ProtocolResponse AssertCacheStorageAndNameForId(
@@ -145,7 +147,7 @@ ProtocolResponse AssertCacheStorageAndNameForId(
   String security_origin;
   ProtocolResponse response =
       ParseCacheId(cache_id, &security_origin, cache_name);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   return AssertCacheStorage(security_origin, frames, caches, result);
 }
@@ -351,9 +353,11 @@ class ResponsesAccumulator : public RefCounted<ResponsesAccumulator> {
   }
 
   void SendFailure(const mojom::blink::CacheStorageError& error) {
-    callback_->sendFailure(ProtocolResponse::Error(String::Format(
-        "Error requesting responses for cache %s : %s",
-        params_.cache_name.Latin1().c_str(), CacheStorageErrorString(error))));
+    callback_->sendFailure(ProtocolResponse::ServerError(
+        String::Format("Error requesting responses for cache %s : %s",
+                       params_.cache_name.Latin1().c_str(),
+                       CacheStorageErrorString(error))
+            .Utf8()));
   }
 
   std::unique_ptr<Array<Header>> SerializeHeaders(
@@ -403,11 +407,12 @@ class GetCacheKeysForRequestData {
                std::unique_ptr<GetCacheKeysForRequestData> self,
                mojom::blink::CacheKeysResultPtr result) {
               if (result->is_status()) {
-                self->callback_->sendFailure(
-                    ProtocolResponse::Error(String::Format(
+                self->callback_->sendFailure(ProtocolResponse::ServerError(
+                    String::Format(
                         "Error requesting requests for cache %s: %s",
                         params.cache_name.Latin1().c_str(),
-                        CacheStorageErrorString(result->get_status()))));
+                        CacheStorageErrorString(result->get_status()))
+                        .Utf8()));
               } else {
                 if (result->get_keys().IsEmpty()) {
                   auto array = std::make_unique<protocol::Array<DataEntry>>();
@@ -454,8 +459,10 @@ class CachedResponseFileReaderLoaderClient final
   }
 
   void DidFail(FileErrorCode error) override {
-    callback_->sendFailure(ProtocolResponse::Error(String::Format(
-        "Unable to read the cached response, error code: %d", error)));
+    callback_->sendFailure(ProtocolResponse::ServerError(
+        String::Format("Unable to read the cached response, error code: %d",
+                       error)
+            .Utf8()));
     dispose();
   }
 
@@ -525,7 +532,7 @@ void InspectorCacheStorageAgent::requestCacheNames(
 
   ProtocolResponse response =
       AssertCacheStorage(security_origin, frames_, &caches_, &cache_storage);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(response);
     return;
   }
@@ -565,7 +572,7 @@ void InspectorCacheStorageAgent::requestEntries(
   mojom::blink::CacheStorage* cache_storage = nullptr;
   ProtocolResponse response = AssertCacheStorageAndNameForId(
       cache_id, frames_, &cache_name, &caches_, &cache_storage);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(response);
     return;
   }
@@ -582,10 +589,11 @@ void InspectorCacheStorageAgent::requestEntries(
              std::unique_ptr<RequestEntriesCallback> callback,
              mojom::blink::OpenResultPtr result) {
             if (result->is_status()) {
-              callback->sendFailure(ProtocolResponse::Error(String::Format(
-                  "Error requesting cache %s: %s",
-                  params.cache_name.Latin1().c_str(),
-                  CacheStorageErrorString(result->get_status()))));
+              callback->sendFailure(ProtocolResponse::ServerError(
+                  String::Format("Error requesting cache %s: %s",
+                                 params.cache_name.Latin1().c_str(),
+                                 CacheStorageErrorString(result->get_status()))
+                      .Utf8()));
             } else {
               auto request = std::make_unique<GetCacheKeysForRequestData>(
                   params, std::move(result->get_cache()), std::move(callback));
@@ -608,7 +616,7 @@ void InspectorCacheStorageAgent::deleteCache(
   mojom::blink::CacheStorage* cache_storage = nullptr;
   ProtocolResponse response = AssertCacheStorageAndNameForId(
       cache_id, frames_, &cache_name, &caches_, &cache_storage);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(response);
     return;
   }
@@ -620,9 +628,10 @@ void InspectorCacheStorageAgent::deleteCache(
             if (error == mojom::blink::CacheStorageError::kSuccess) {
               callback->sendSuccess();
             } else {
-              callback->sendFailure(ProtocolResponse::Error(
+              callback->sendFailure(ProtocolResponse::ServerError(
                   String::Format("Error requesting cache names: %s",
-                                 CacheStorageErrorString(error))));
+                                 CacheStorageErrorString(error))
+                      .Utf8()));
             }
           },
           std::move(callback)));
@@ -641,7 +650,7 @@ void InspectorCacheStorageAgent::deleteEntry(
   mojom::blink::CacheStorage* cache_storage = nullptr;
   ProtocolResponse response = AssertCacheStorageAndNameForId(
       cache_id, frames_, &cache_name, &caches_, &cache_storage);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(response);
     return;
   }
@@ -652,9 +661,11 @@ void InspectorCacheStorageAgent::deleteEntry(
              std::unique_ptr<DeleteEntryCallback> callback,
              mojom::blink::OpenResultPtr result) {
             if (result->is_status()) {
-              callback->sendFailure(ProtocolResponse::Error(String::Format(
-                  "Error requesting cache %s: %s", cache_name.Latin1().c_str(),
-                  CacheStorageErrorString(result->get_status()))));
+              callback->sendFailure(ProtocolResponse::ServerError(
+                  String::Format("Error requesting cache %s: %s",
+                                 cache_name.Latin1().c_str(),
+                                 CacheStorageErrorString(result->get_status()))
+                      .Utf8()));
             } else {
               Vector<mojom::blink::BatchOperationPtr> batch_operations;
               batch_operations.push_back(mojom::blink::BatchOperation::New());
@@ -677,10 +688,11 @@ void InspectorCacheStorageAgent::deleteEntry(
                          mojom::blink::CacheStorageVerboseErrorPtr error) {
                         if (error->value !=
                             mojom::blink::CacheStorageError::kSuccess) {
-                          callback->sendFailure(
-                              ProtocolResponse::Error(String::Format(
+                          callback->sendFailure(ProtocolResponse::ServerError(
+                              String::Format(
                                   "Error deleting cache entry: %s",
-                                  CacheStorageErrorString(error->value))));
+                                  CacheStorageErrorString(error->value))
+                                  .Utf8()));
                         } else {
                           callback->sendSuccess();
                         }
@@ -706,7 +718,7 @@ void InspectorCacheStorageAgent::requestCachedResponse(
   mojom::blink::CacheStorage* cache_storage = nullptr;
   ProtocolResponse response = AssertCacheStorageAndNameForId(
       cache_id, frames_, &cache_name, &caches_, &cache_storage);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     callback->sendFailure(response);
     return;
   }
@@ -729,9 +741,10 @@ void InspectorCacheStorageAgent::requestCachedResponse(
           [](std::unique_ptr<RequestCachedResponseCallback> callback,
              mojom::blink::MatchResultPtr result) {
             if (result->is_status()) {
-              callback->sendFailure(ProtocolResponse::Error(String::Format(
-                  "Unable to read cached response: %s",
-                  CacheStorageErrorString(result->get_status()))));
+              callback->sendFailure(ProtocolResponse::ServerError(
+                  String::Format("Unable to read cached response: %s",
+                                 CacheStorageErrorString(result->get_status()))
+                      .Utf8()));
             } else {
               std::unique_ptr<protocol::DictionaryValue> headers =
                   protocol::DictionaryValue::create();

third_party/blink/renderer/modules/device_orientation/device_orientation_inspector_agent.cc

@@ -51,7 +51,7 @@ Response DeviceOrientationInspectorAgent::setDeviceOrientationOverride(
         DeviceOrientationData::Create(alpha, beta, gamma, false));
   }
   sensor_agent_->SetOrientationSensorOverride(alpha, beta, gamma);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response DeviceOrientationInspectorAgent::clearDeviceOrientationOverride() {
@@ -63,7 +63,7 @@ Response DeviceOrientationInspectorAgent::disable() {
   if (Controller())
     Controller()->ClearOverride();
   sensor_agent_->Disable();
-  return Response::OK();
+  return Response::Success();
 }
 
 void DeviceOrientationInspectorAgent::Restore() {

third_party/blink/renderer/modules/indexeddb/inspector_indexed_db_agent.cc

@@ -101,13 +101,13 @@ const char kNoDocumentError[] = "No document for given frame found";
 Response AssertIDBFactory(Document* document, IDBFactory*& result) {
   LocalDOMWindow* dom_window = document->domWindow();
   if (!dom_window)
-    return Response::Error("No IndexedDB factory for given frame found");
+    return Response::ServerError("No IndexedDB factory for given frame found");
   IDBFactory* idb_factory = GlobalIndexedDB::indexedDB(*dom_window);
 
   if (!idb_factory)
-    return Response::Error("No IndexedDB factory for given frame found");
+    return Response::ServerError("No IndexedDB factory for given frame found");
   result = idb_factory;
-  return Response::OK();
+  return Response::Success();
 }
 
 class GetDatabaseNamesCallback final : public NativeEventListener {
@@ -121,7 +121,8 @@ class GetDatabaseNamesCallback final : public NativeEventListener {
 
   void Invoke(ExecutionContext*, Event* event) override {
     if (event->type() != event_type_names::kSuccess) {
-      request_callback_->sendFailure(Response::Error("Unexpected event type."));
+      request_callback_->sendFailure(
+          Response::ServerError("Unexpected event type."));
       return;
     }
 
@@ -129,7 +130,7 @@ class GetDatabaseNamesCallback final : public NativeEventListener {
     IDBAny* request_result = idb_request->ResultAsAny();
     if (request_result->GetType() != IDBAny::kDOMStringListType) {
       request_callback_->sendFailure(
-          Response::Error("Unexpected result type."));
+          Response::ServerError("Unexpected result type."));
       return;
     }
 
@@ -156,7 +157,7 @@ class DeleteCallback final : public NativeEventListener {
   void Invoke(ExecutionContext*, Event* event) override {
     if (event->type() != event_type_names::kSuccess) {
       request_callback_->sendFailure(
-          Response::Error("Failed to delete database."));
+          Response::ServerError("Failed to delete database."));
       return;
     }
     request_callback_->sendSuccess();
@@ -182,12 +183,12 @@ class ExecutableWithDatabase
   void Start(LocalFrame* frame, const String& database_name) {
     Document* document = frame ? frame->GetDocument() : nullptr;
     if (!document) {
-      SendFailure(Response::Error(kNoDocumentError));
+      SendFailure(Response::ServerError(kNoDocumentError));
       return;
     }
     IDBFactory* idb_factory = nullptr;
     Response response = AssertIDBFactory(document, idb_factory);
-    if (!response.isSuccess()) {
+    if (!response.IsSuccess()) {
       SendFailure(response);
       return;
     }
@@ -216,7 +217,7 @@ class ExecutableWithDatabase
     IDBOpenDBRequest* idb_open_db_request =
         idb_factory->open(script_state, database_name, exception_state);
     if (exception_state.HadException()) {
-      SendFailure(Response::Error("Could not open database."));
+      SendFailure(Response::ServerError("Could not open database."));
       return;
     }
     idb_open_db_request->addEventListener(event_type_names::kUpgradeneeded,
@@ -250,7 +251,7 @@ class OpenDatabaseCallback final : public NativeEventListener {
   void Invoke(ExecutionContext* context, Event* event) override {
     if (event->type() != event_type_names::kSuccess) {
       executable_with_database_->GetRequestCallback()->sendFailure(
-          Response::Error("Unexpected event type."));
+          Response::ServerError("Unexpected event type."));
       return;
     }
 
@@ -259,7 +260,7 @@ class OpenDatabaseCallback final : public NativeEventListener {
     IDBAny* request_result = idb_open_db_request->ResultAsAny();
     if (request_result->GetType() != IDBAny::kIDBDatabaseType) {
       executable_with_database_->GetRequestCallback()->sendFailure(
-          Response::Error("Unexpected result type."));
+          Response::ServerError("Unexpected result type."));
       return;
     }
 
@@ -297,7 +298,7 @@ class UpgradeDatabaseCallback final : public NativeEventListener {
   void Invoke(ExecutionContext* context, Event* event) override {
     if (event->type() != event_type_names::kUpgradeneeded) {
       executable_with_database_->GetRequestCallback()->sendFailure(
-          Response::Error("Unexpected event type."));
+          Response::ServerError("Unexpected event type."));
       return;
     }
 
@@ -309,7 +310,7 @@ class UpgradeDatabaseCallback final : public NativeEventListener {
     NonThrowableExceptionState exception_state;
     idb_open_db_request->transaction()->abort(exception_state);
     executable_with_database_->GetRequestCallback()->sendFailure(
-        Response::Error("Aborted upgrade."));
+        Response::ServerError("Aborted upgrade."));
   }
 
  private:
@@ -537,7 +538,8 @@ class OpenCursorCallback final : public NativeEventListener {
 
   void Invoke(ExecutionContext*, Event* event) override {
     if (event->type() != event_type_names::kSuccess) {
-      request_callback_->sendFailure(Response::Error("Unexpected event type."));
+      request_callback_->sendFailure(
+          Response::ServerError("Unexpected event type."));
       return;
     }
 
@@ -549,7 +551,7 @@ class OpenCursorCallback final : public NativeEventListener {
     }
     if (request_result->GetType() != IDBAny::kIDBCursorWithValueType) {
       request_callback_->sendFailure(
-          Response::Error("Unexpected result type."));
+          Response::ServerError("Unexpected result type."));
       return;
     }
 
@@ -560,7 +562,7 @@ class OpenCursorCallback final : public NativeEventListener {
       idb_cursor->advance(skip_count_, exception_state);
       if (exception_state.HadException()) {
         request_callback_->sendFailure(
-            Response::Error("Could not advance cursor."));
+            Response::ServerError("Could not advance cursor."));
       }
       skip_count_ = 0;
       return;
@@ -578,7 +580,7 @@ class OpenCursorCallback final : public NativeEventListener {
                          exception_state);
     if (exception_state.HadException()) {
       request_callback_->sendFailure(
-          Response::Error("Could not continue cursor."));
+          Response::ServerError("Could not continue cursor."));
       return;
     }
 
@@ -644,14 +646,14 @@ class DataLoader final : public ExecutableWithDatabase<RequestDataCallback> {
         TransactionForDatabase(script_state, idb_database, object_store_name_);
     if (!idb_transaction) {
       request_callback_->sendFailure(
-          Response::Error("Could not get transaction"));
+          Response::ServerError("Could not get transaction"));
       return;
     }
     IDBObjectStore* idb_object_store =
         ObjectStoreForTransaction(idb_transaction, object_store_name_);
     if (!idb_object_store) {
       request_callback_->sendFailure(
-          Response::Error("Could not get object store"));
+          Response::ServerError("Could not get object store"));
       return;
     }
 
@@ -659,7 +661,8 @@ class DataLoader final : public ExecutableWithDatabase<RequestDataCallback> {
     if (!index_name_.IsEmpty()) {
       IDBIndex* idb_index = IndexForObjectStore(idb_object_store, index_name_);
       if (!idb_index) {
-        request_callback_->sendFailure(Response::Error("Could not get index"));
+        request_callback_->sendFailure(
+            Response::ServerError("Could not get index"));
         return;
       }
 
@@ -729,14 +732,14 @@ void InspectorIndexedDBAgent::DidCommitLoadForLocalFrame(LocalFrame* frame) {
 
 Response InspectorIndexedDBAgent::enable() {
   enabled_.Set(true);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorIndexedDBAgent::disable() {
   enabled_.Clear();
   v8_session_->releaseObjectGroup(
       ToV8InspectorStringView(kIndexedDBObjectGroup));
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorIndexedDBAgent::requestDatabaseNames(
@@ -746,12 +749,12 @@ void InspectorIndexedDBAgent::requestDatabaseNames(
       inspected_frames_->FrameWithSecurityOrigin(security_origin);
   Document* document = frame ? frame->GetDocument() : nullptr;
   if (!document) {
-    request_callback->sendFailure(Response::Error(kNoDocumentError));
+    request_callback->sendFailure(Response::ServerError(kNoDocumentError));
     return;
   }
   IDBFactory* idb_factory = nullptr;
   Response response = AssertIDBFactory(document, idb_factory);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     request_callback->sendFailure(response);
     return;
   }
@@ -767,7 +770,7 @@ void InspectorIndexedDBAgent::requestDatabaseNames(
       idb_factory->GetDatabaseNames(script_state, exception_state);
   if (exception_state.HadException()) {
     request_callback->sendFailure(
-        Response::Error("Could not obtain database names."));
+        Response::ServerError("Could not obtain database names."));
     return;
   }
   idb_request->addEventListener(
@@ -802,7 +805,8 @@ void InspectorIndexedDBAgent::requestData(
       key_range.isJust() ? IdbKeyRangeFromKeyRange(key_range.fromJust())
                          : nullptr;
   if (key_range.isJust() && !idb_key_range) {
-    request_callback->sendFailure(Response::Error("Can not parse key range."));
+    request_callback->sendFailure(
+        Response::ServerError("Can not parse key range."));
     return;
   }
 
@@ -857,7 +861,7 @@ class GetMetadata final : public ExecutableWithDatabase<GetMetadataCallback> {
 
   void NotifySubtaskDone(const String& error) {
     if (!error.IsNull()) {
-      request_callback_->sendFailure(Response::Error(error));
+      request_callback_->sendFailure(Response::ServerError(error.Utf8()));
       return;
     }
     if (--subtask_pending_ == 0) {
@@ -881,14 +885,14 @@ class GetMetadata final : public ExecutableWithDatabase<GetMetadataCallback> {
                                indexed_db_names::kReadonly);
     if (!idb_transaction) {
       request_callback_->sendFailure(
-          Response::Error("Could not get transaction"));
+          Response::ServerError("Could not get transaction"));
       return;
     }
     IDBObjectStore* idb_object_store =
         ObjectStoreForTransaction(idb_transaction, object_store_name_);
     if (!idb_object_store) {
       request_callback_->sendFailure(
-          Response::Error("Could not get object store"));
+          Response::ServerError("Could not get object store"));
       return;
     }
 
@@ -901,9 +905,10 @@ class GetMetadata final : public ExecutableWithDatabase<GetMetadataCallback> {
     DCHECK(!exception_state.HadException());
     if (exception_state.HadException()) {
       ExceptionCode ec = exception_state.Code();
-      request_callback_->sendFailure(Response::Error(
+      request_callback_->sendFailure(Response::ServerError(
           String::Format("Could not count entries in object store '%s': %d",
-                         object_store_name_.Utf8().c_str(), ec)));
+                         object_store_name_.Latin1().c_str(), ec)
+              .Utf8()));
       return;
     }
     GetMetadataListener* listener_get_entries_count =
@@ -964,7 +969,7 @@ class DeleteObjectStoreEntriesListener final : public NativeEventListener {
   void Invoke(ExecutionContext*, Event* event) override {
     if (event->type() != event_type_names::kSuccess) {
       request_callback_->sendFailure(
-          Response::Error("Failed to delete specified entries"));
+          Response::ServerError("Failed to delete specified entries"));
       return;
     }
 
@@ -1000,14 +1005,14 @@ class DeleteObjectStoreEntries final
                                indexed_db_names::kReadwrite);
     if (!idb_transaction) {
       request_callback_->sendFailure(
-          Response::Error("Could not get transaction"));
+          Response::ServerError("Could not get transaction"));
       return;
     }
     IDBObjectStore* idb_object_store =
         ObjectStoreForTransaction(idb_transaction, object_store_name_);
     if (!idb_object_store) {
       request_callback_->sendFailure(
-          Response::Error("Could not get object store"));
+          Response::ServerError("Could not get object store"));
       return;
     }
 
@@ -1038,7 +1043,8 @@ void InspectorIndexedDBAgent::deleteObjectStoreEntries(
     std::unique_ptr<DeleteObjectStoreEntriesCallback> request_callback) {
   IDBKeyRange* idb_key_range = IdbKeyRangeFromKeyRange(key_range.get());
   if (!idb_key_range) {
-    request_callback->sendFailure(Response::Error("Can not parse key range"));
+    request_callback->sendFailure(
+        Response::ServerError("Can not parse key range"));
     return;
   }
   scoped_refptr<DeleteObjectStoreEntries> delete_object_store_entries =
@@ -1058,7 +1064,8 @@ class ClearObjectStoreListener final : public NativeEventListener {
 
   void Invoke(ExecutionContext*, Event* event) override {
     if (event->type() != event_type_names::kComplete) {
-      request_callback_->sendFailure(Response::Error("Unexpected event type."));
+      request_callback_->sendFailure(
+          Response::ServerError("Unexpected event type."));
       return;
     }
 
@@ -1090,14 +1097,14 @@ class ClearObjectStore final
                                indexed_db_names::kReadwrite);
     if (!idb_transaction) {
       request_callback_->sendFailure(
-          Response::Error("Could not get transaction"));
+          Response::ServerError("Could not get transaction"));
       return;
     }
     IDBObjectStore* idb_object_store =
         ObjectStoreForTransaction(idb_transaction, object_store_name_);
     if (!idb_object_store) {
       request_callback_->sendFailure(
-          Response::Error("Could not get object store"));
+          Response::ServerError("Could not get object store"));
       return;
     }
 
@@ -1106,9 +1113,10 @@ class ClearObjectStore final
     DCHECK(!exception_state.HadException());
     if (exception_state.HadException()) {
       ExceptionCode ec = exception_state.Code();
-      request_callback_->sendFailure(Response::Error(
+      request_callback_->sendFailure(Response::ServerError(
           String::Format("Could not clear object store '%s': %d",
-                         object_store_name_.Utf8().c_str(), ec)));
+                         object_store_name_.Latin1().c_str(), ec)
+              .Utf8()));
       return;
     }
     idb_transaction->addEventListener(
@@ -1147,12 +1155,12 @@ void InspectorIndexedDBAgent::deleteDatabase(
       inspected_frames_->FrameWithSecurityOrigin(security_origin);
   Document* document = frame ? frame->GetDocument() : nullptr;
   if (!document) {
-    request_callback->sendFailure(Response::Error(kNoDocumentError));
+    request_callback->sendFailure(Response::ServerError(kNoDocumentError));
     return;
   }
   IDBFactory* idb_factory = nullptr;
   Response response = AssertIDBFactory(document, idb_factory);
-  if (!response.isSuccess()) {
+  if (!response.IsSuccess()) {
     request_callback->sendFailure(response);
     return;
   }
@@ -1168,7 +1176,7 @@ void InspectorIndexedDBAgent::deleteDatabase(
       script_state, database_name, exception_state);
   if (exception_state.HadException()) {
     request_callback->sendFailure(
-        Response::Error("Could not delete database."));
+        Response::ServerError("Could not delete database."));
     return;
   }
   idb_request->addEventListener(

third_party/blink/renderer/modules/storage/inspector_dom_storage_agent.cc

@@ -49,14 +49,15 @@ using protocol::Response;
 
 static Response ToResponse(ExceptionState& exception_state) {
   if (!exception_state.HadException())
-    return Response::OK();
+    return Response::Success();
 
   String name_prefix = IsDOMExceptionCode(exception_state.Code())
                            ? DOMException::GetErrorName(
                                  exception_state.CodeAs<DOMExceptionCode>()) +
                                  " "
                            : g_empty_string;
-  return Response::Error(name_prefix + exception_state.Message());
+  String msg = name_prefix + exception_state.Message();
+  return Response::ServerError(msg.Utf8());
 }
 
 InspectorDOMStorageAgent::InspectorDOMStorageAgent(
@@ -86,15 +87,15 @@ void InspectorDOMStorageAgent::InnerEnable() {
 
 Response InspectorDOMStorageAgent::enable() {
   if (enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Set(true);
   InnerEnable();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMStorageAgent::disable() {
   if (!enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Set(false);
   StorageController::GetInstance()->RemoveLocalStorageInspectorStorageAgent(
       this);
@@ -102,20 +103,20 @@ Response InspectorDOMStorageAgent::disable() {
       StorageNamespace::From(inspected_frames_->Root()->GetPage());
   if (ns)
     ns->RemoveInspectorStorageAgent(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMStorageAgent::clear(
     std::unique_ptr<protocol::DOMStorage::StorageId> storage_id) {
   StorageArea* storage_area = nullptr;
   Response response = FindStorageArea(std::move(storage_id), storage_area);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
   DummyExceptionStateForTesting exception_state;
   storage_area->clear(exception_state);
   if (exception_state.HadException())
-    return Response::Error("Could not clear the storage");
-  return Response::OK();
+    return Response::ServerError("Could not clear the storage");
+  return Response::Success();
 }
 
 Response InspectorDOMStorageAgent::getDOMStorageItems(
@@ -123,7 +124,7 @@ Response InspectorDOMStorageAgent::getDOMStorageItems(
     std::unique_ptr<protocol::Array<protocol::Array<String>>>* items) {
   StorageArea* storage_area = nullptr;
   Response response = FindStorageArea(std::move(storage_id), storage_area);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   auto storage_items =
@@ -133,11 +134,11 @@ Response InspectorDOMStorageAgent::getDOMStorageItems(
   for (unsigned i = 0; i < storage_area->length(exception_state); ++i) {
     String name(storage_area->key(i, exception_state));
     response = ToResponse(exception_state);
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
     String value(storage_area->getItem(name, exception_state));
     response = ToResponse(exception_state);
-    if (!response.isSuccess())
+    if (!response.IsSuccess())
       return response;
     auto entry = std::make_unique<protocol::Array<String>>();
     entry->emplace_back(name);
@@ -145,7 +146,7 @@ Response InspectorDOMStorageAgent::getDOMStorageItems(
     storage_items->emplace_back(std::move(entry));
   }
   *items = std::move(storage_items);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDOMStorageAgent::setDOMStorageItem(
@@ -154,7 +155,7 @@ Response InspectorDOMStorageAgent::setDOMStorageItem(
     const String& value) {
   StorageArea* storage_area = nullptr;
   Response response = FindStorageArea(std::move(storage_id), storage_area);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -167,7 +168,7 @@ Response InspectorDOMStorageAgent::removeDOMStorageItem(
     const String& key) {
   StorageArea* storage_area = nullptr;
   Response response = FindStorageArea(std::move(storage_id), storage_area);
-  if (!response.isSuccess())
+  if (!response.IsSuccess())
     return response;
 
   DummyExceptionStateForTesting exception_state;
@@ -214,26 +215,31 @@ Response InspectorDOMStorageAgent::FindStorageArea(
   bool is_local_storage = storage_id->getIsLocalStorage();
   LocalFrame* frame =
       inspected_frames_->FrameWithSecurityOrigin(security_origin);
-  if (!frame)
-    return Response::Error("Frame not found for the given security origin");
-
+  if (!frame) {
+    return Response::ServerError(
+        "Frame not found for the given security origin");
+  }
   if (is_local_storage) {
-    if (!frame->GetDocument()->GetSecurityOrigin()->CanAccessLocalStorage())
-      return Response::Error("Security origin cannot access local storage");
+    if (!frame->GetDocument()->GetSecurityOrigin()->CanAccessLocalStorage()) {
+      return Response::ServerError(
+          "Security origin cannot access local storage");
+    }
     storage_area = StorageArea::CreateForInspectorAgent(
         frame,
         StorageController::GetInstance()->GetLocalStorageArea(
             frame->GetDocument()->GetSecurityOrigin()),
         StorageArea::StorageType::kLocalStorage);
-    return Response::OK();
+    return Response::Success();
   }
 
-  if (!frame->GetDocument()->GetSecurityOrigin()->CanAccessSessionStorage())
-    return Response::Error("Security origin cannot access session storage");
+  if (!frame->GetDocument()->GetSecurityOrigin()->CanAccessSessionStorage()) {
+    return Response::ServerError(
+        "Security origin cannot access session storage");
+  }
   StorageNamespace* session_namespace =
       StorageNamespace::From(frame->GetPage());
   if (!session_namespace)
-    return Response::Error("SessionStorage is not supported");
+    return Response::ServerError("SessionStorage is not supported");
   DCHECK(session_namespace->IsSessionStorage());
 
   storage_area = StorageArea::CreateForInspectorAgent(
@@ -241,7 +247,7 @@ Response InspectorDOMStorageAgent::FindStorageArea(
       session_namespace->GetCachedArea(
           frame->GetDocument()->GetSecurityOrigin()),
       StorageArea::StorageType::kSessionStorage);
-  return Response::OK();
+  return Response::Success();
 }
 
 }  // namespace blink

third_party/blink/renderer/modules/webaudio/inspector_web_audio_agent.cc

@@ -74,20 +74,20 @@ void InspectorWebAudioAgent::Restore() {
 
 Response InspectorWebAudioAgent::enable() {
   if (enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Set(true);
   AudioGraphTracer* graph_tracer = AudioGraphTracer::FromPage(page_);
   graph_tracer->SetInspectorAgent(this);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorWebAudioAgent::disable() {
   if (!enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Clear();
   AudioGraphTracer* graph_tracer = AudioGraphTracer::FromPage(page_);
   graph_tracer->SetInspectorAgent(nullptr);
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorWebAudioAgent::getRealtimeData(
@@ -95,14 +95,14 @@ Response InspectorWebAudioAgent::getRealtimeData(
     std::unique_ptr<ContextRealtimeData>* out_data) {
   auto* const graph_tracer = AudioGraphTracer::FromPage(page_);
   if (!enabled_.Get())
-    return Response::Error("Enable agent first.");
+    return Response::ServerError("Enable agent first.");
 
   BaseAudioContext* context = graph_tracer->GetContextById(contextId);
   if (!context)
-    return Response::Error("Cannot find BaseAudioContext with such id.");
+    return Response::ServerError("Cannot find BaseAudioContext with such id.");
 
   if (!context->HasRealtimeConstraint()) {
-    return Response::Error(
+    return Response::ServerError(
         "ContextRealtimeData is only avaliable for an AudioContext.");
   }
 
@@ -115,7 +115,7 @@ Response InspectorWebAudioAgent::getRealtimeData(
           .setCallbackIntervalMean(metric.mean_callback_interval)
           .setCallbackIntervalVariance(metric.variance_callback_interval)
           .build();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorWebAudioAgent::DidCreateBaseAudioContext(

third_party/blink/renderer/modules/webdatabase/inspector_database_agent.cc

@@ -235,20 +235,20 @@ void InspectorDatabaseAgent::InnerEnable() {
 
 Response InspectorDatabaseAgent::enable() {
   if (enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Set(true);
   InnerEnable();
-  return Response::OK();
+  return Response::Success();
 }
 
 Response InspectorDatabaseAgent::disable() {
   if (!enabled_.Get())
-    return Response::OK();
+    return Response::Success();
   enabled_.Set(false);
   if (DatabaseClient* client = DatabaseClient::FromPage(page_))
     client->SetInspectorAgent(nullptr);
   resources_.clear();
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorDatabaseAgent::Restore() {
@@ -260,7 +260,7 @@ Response InspectorDatabaseAgent::getDatabaseTableNames(
     const String& database_id,
     std::unique_ptr<protocol::Array<String>>* names) {
   if (!enabled_.Get())
-    return Response::Error("Database agent is not enabled");
+    return Response::ServerError("Database agent is not enabled");
 
   blink::Database* database = DatabaseForId(database_id);
   if (database) {
@@ -270,7 +270,7 @@ Response InspectorDatabaseAgent::getDatabaseTableNames(
   } else {
     *names = std::make_unique<protocol::Array<String>>();
   }
-  return Response::OK();
+  return Response::Success();
 }
 
 void InspectorDatabaseAgent::executeSQL(
@@ -282,13 +282,13 @@ void InspectorDatabaseAgent::executeSQL(
 
   if (!enabled_.Get()) {
     request_callback->sendFailure(
-        Response::Error("Database agent is not enabled"));
+        Response::ServerError("Database agent is not enabled"));
     return;
   }
 
   blink::Database* database = DatabaseForId(database_id);
   if (!database) {
-    request_callback->sendFailure(Response::Error("Database not found"));
+    request_callback->sendFailure(Response::ServerError("Database not found"));
     return;
   }
 

third_party/blink/web_tests/http/tests/devtools/report-protocol-errors-expected.txt

@@ -3,7 +3,7 @@ Tests that InspectorBackendDispatcher is catching incorrect messages.
 {
     error : {
         code : -32700
-        message : "Message must be a valid JSON"
+        message : "JSON: invalid token at position 0"
     }
 }
 -------------------------------------------------------

third_party/blink/web_tests/inspector-protocol/target/target-send-message-expected.txt

@@ -1,8 +1,8 @@
 Tests sendMessage with invalid message.
 JSON syntax error..
-{"error":{"code":-32700,"message":"Message must be a valid JSON"}}
+{"error":{"code":-32700,"message":"JSON: string literal expected at position 57"}}
 JSON with primitive value..
-{"error":{"code":-32700,"message":"Message must be a valid JSON"}}
+{"error":{"code":-32600,"message":"Message must be an object"}}
 JSON without method property..
 {"error":{"code":-32600,"message":"Message must have integer 'id' property"}}
 JSON without id property..

third_party/inspector_protocol/BUILD.gn

@@ -8,9 +8,13 @@ jumbo_component("crdtp") {
   sources = [
     "crdtp/cbor.cc",
     "crdtp/cbor.h",
+    "crdtp/dispatch.cc",
+    "crdtp/dispatch.h",
     "crdtp/error_support.cc",
     "crdtp/error_support.h",
     "crdtp/export.h",
+    "crdtp/find_by_first.h",
+    "crdtp/frontend_channel.h",
     "crdtp/glue.h",
     "crdtp/json.cc",
     "crdtp/json.h",
@@ -18,6 +22,7 @@ jumbo_component("crdtp") {
     "crdtp/serializable.cc",
     "crdtp/serializable.h",
     "crdtp/serializer_traits.h",
+    "crdtp/span.cc",
     "crdtp/span.h",
     "crdtp/status.cc",
     "crdtp/status.h",
@@ -47,7 +52,9 @@ source_set("crdtp_test") {
   testonly = true
   sources = [
     "crdtp/cbor_test.cc",
+    "crdtp/dispatch_test.cc",
     "crdtp/error_support_test.cc",
+    "crdtp/find_by_first_test.cc",
     "crdtp/glue_test.cc",
     "crdtp/json_test.cc",
     "crdtp/serializable_test.cc",

third_party/inspector_protocol/README.chromium

@@ -2,7 +2,7 @@ Name: inspector protocol
 Short Name: inspector_protocol
 URL: https://chromium.googlesource.com/deps/inspector_protocol/
 Version: 0
-Revision: 81ef742ba3587767fc08652d299df9e9b7051407
+Revision: 8c2064ea99cffdb5647760ad3953c43e612e07fc
 License: BSD
 License File: LICENSE
 Security Critical: yes