[DevTools] migrate InspectorLayerTreeAgent to new style

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

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 164 matching lines @@
   visitor->trace(m_inspectedFrames);
   InspectorBaseAgent::trace(visitor);
 }
 
 void InspectorLayerTreeAgent::restore() {
   // We do not re-enable layer agent automatically after navigation. This is
   // because it depends on DOMAgent and node ids in particular, so we let
   // front-end request document and re-enable the agent manually after this.
 }
 
-void InspectorLayerTreeAgent::enable(ErrorString*) {
+Response InspectorLayerTreeAgent::enable() {
   m_instrumentingAgents->addInspectorLayerTreeAgent(this);
   Document* document = m_inspectedFrames->root()->document();
   if (document &&
       document->lifecycle().state() >= DocumentLifecycle::CompositingClean)
     layerTreeDidChange();
+  return Response::OK();
 }
 
-void InspectorLayerTreeAgent::disable(ErrorString*) {
+Response InspectorLayerTreeAgent::disable() {
   m_instrumentingAgents->removeInspectorLayerTreeAgent(this);
   m_snapshotById.clear();
-  ErrorString unused;
+  return Response::OK();
 }
 
 void InspectorLayerTreeAgent::layerTreeDidChange() {
   frontend()->layerTreeDidChange(buildLayerTree());
 }
 
 void InspectorLayerTreeAgent::didPaint(const GraphicsLayer* graphicsLayer,
                                        GraphicsContext&,
                                        const LayoutRect& rect) {
   if (m_suppressLayerPaintEvents)
@@ skipping 101 matching lines @@
 static GraphicsLayer* findLayerById(GraphicsLayer* root, int layerId) {
   if (root->platformLayer()->id() == layerId)
     return root;
   for (size_t i = 0, size = root->children().size(); i < size; ++i) {
     if (GraphicsLayer* layer = findLayerById(root->children()[i], layerId))
       return layer;
   }
   return nullptr;
 }
 
-GraphicsLayer* InspectorLayerTreeAgent::layerById(ErrorString* errorString,
-                                                  const String& layerId) {
+Response InspectorLayerTreeAgent::layerById(const String& layerId,
+                                            GraphicsLayer*& result) {
   bool ok;
   int id = layerId.toInt(&ok);
-  if (!ok) {
-    *errorString = "Invalid layer id";
-    return nullptr;
-  }
+  if (!ok)
+    return Response::Error("Invalid layer id");
   PaintLayerCompositor* compositor = paintLayerCompositor();
-  if (!compositor) {
-    *errorString = "Not in compositing mode";
-    return nullptr;
-  }
+  if (!compositor)
+    return Response::Error("Not in compositing mode");
 
-  GraphicsLayer* result = findLayerById(rootGraphicsLayer(), id);
+  result = findLayerById(rootGraphicsLayer(), id);
   if (!result)
-    *errorString = "No layer matching given id found";
-  return result;
+    return Response::Error("No layer matching given id found");
+  return Response::OK();
 }
 
-void InspectorLayerTreeAgent::compositingReasons(
-    ErrorString* errorString,
+Response InspectorLayerTreeAgent::compositingReasons(
     const String& layerId,
     std::unique_ptr<Array<String>>* reasonStrings) {
-  const GraphicsLayer* graphicsLayer = layerById(errorString, layerId);
-  if (!graphicsLayer)
-    return;
+  GraphicsLayer* graphicsLayer = nullptr;
+  Response response = layerById(layerId, graphicsLayer);
+  if (!response.isSuccess())
+    return response;
   CompositingReasons reasonsBitmask = graphicsLayer->getCompositingReasons();
   *reasonStrings = Array<String>::create();
   for (size_t i = 0; i < kNumberOfCompositingReasons; ++i) {
     if (!(reasonsBitmask & kCompositingReasonStringMap[i].reason))
       continue;
     (*reasonStrings)->addItem(kCompositingReasonStringMap[i].shortName);
 #ifndef _NDEBUG
     reasonsBitmask &= ~kCompositingReasonStringMap[i].reason;
 #endif
   }
   ASSERT(!reasonsBitmask);
+  return Response::OK();
 }
 
-void InspectorLayerTreeAgent::makeSnapshot(ErrorString* errorString,
-                                           const String& layerId,
-                                           String* snapshotId) {
-  GraphicsLayer* layer = layerById(errorString, layerId);
-  if (!layer || !layer->drawsContent())
-    return;
+Response InspectorLayerTreeAgent::makeSnapshot(const String& layerId,
+                                               String* snapshotId) {
+  GraphicsLayer* layer = nullptr;
+  Response response = layerById(layerId, layer);
+  if (!response.isSuccess())
+    return response;
+  if (!layer->drawsContent())
+    return Response::Error("Layer does not draw content");
 
   IntSize size = expandedIntSize(layer->size());
 
   IntRect interestRect(IntPoint(0, 0), size);
   m_suppressLayerPaintEvents = true;
   layer->paint(&interestRect);
   m_suppressLayerPaintEvents = false;
 
   GraphicsContext context(layer->getPaintController());
   context.beginRecording(interestRect);
   layer->getPaintController().paintArtifact().replay(context);
   RefPtr<PictureSnapshot> snapshot =
       adoptRef(new PictureSnapshot(context.endRecording()));
 
   *snapshotId = String::number(++s_lastSnapshotId);
   bool newEntry = m_snapshotById.add(*snapshotId, snapshot).isNewEntry;
   DCHECK(newEntry);
+  return Response::OK();
 }
 
-void InspectorLayerTreeAgent::loadSnapshot(
-    ErrorString* errorString,
+Response InspectorLayerTreeAgent::loadSnapshot(
     std::unique_ptr<Array<protocol::LayerTree::PictureTile>> tiles,
     String* snapshotId) {
-  if (!tiles->length()) {
-    *errorString = "Invalid argument, no tiles provided";
-    return;
-  }
+  if (!tiles->length())
+    return Response::Error("Invalid argument, no tiles provided");
   Vector<RefPtr<PictureSnapshot::TilePictureStream>> decodedTiles;
   decodedTiles.grow(tiles->length());
   for (size_t i = 0; i < tiles->length(); ++i) {
     protocol::LayerTree::PictureTile* tile = tiles->get(i);
     decodedTiles[i] = adoptRef(new PictureSnapshot::TilePictureStream());
     decodedTiles[i]->layerOffset.set(tile->getX(), tile->getY());
-    if (!base64Decode(tile->getPicture(), decodedTiles[i]->data)) {
-      *errorString = "Invalid base64 encoding";
-      return;
-    }
+    if (!base64Decode(tile->getPicture(), decodedTiles[i]->data))
+      return Response::Error("Invalid base64 encoding");
   }
   RefPtr<PictureSnapshot> snapshot = PictureSnapshot::load(decodedTiles);
-  if (!snapshot) {
-    *errorString = "Invalid snapshot format";
-    return;
-  }
-  if (snapshot->isEmpty()) {
-    *errorString = "Empty snapshot";
-    return;
-  }
+  if (!snapshot)
+    return Response::Error("Invalid snapshot format");
+  if (snapshot->isEmpty())
+    return Response::Error("Empty snapshot");
 
   *snapshotId = String::number(++s_lastSnapshotId);
   bool newEntry = m_snapshotById.add(*snapshotId, snapshot).isNewEntry;
   DCHECK(newEntry);
+  return Response::OK();
 }
 
-void InspectorLayerTreeAgent::releaseSnapshot(ErrorString* errorString,
-                                              const String& snapshotId) {
+Response InspectorLayerTreeAgent::releaseSnapshot(const String& snapshotId) {
   SnapshotById::iterator it = m_snapshotById.find(snapshotId);
-  if (it == m_snapshotById.end()) {
-    *errorString = "Snapshot not found";
-    return;
-  }
+  if (it == m_snapshotById.end())
+    return Response::Error("Snapshot not found");
   m_snapshotById.remove(it);
+  return Response::OK();
 }
 
-const PictureSnapshot* InspectorLayerTreeAgent::snapshotById(
-    ErrorString* errorString,
-    const String& snapshotId) {
+Response InspectorLayerTreeAgent::snapshotById(const String& snapshotId,
+                                               const PictureSnapshot*& result) {
   SnapshotById::iterator it = m_snapshotById.find(snapshotId);
-  if (it == m_snapshotById.end()) {
-    *errorString = "Snapshot not found";
-    return nullptr;
-  }
-  return it->value.get();
+  if (it == m_snapshotById.end())
+    return Response::Error("Snapshot not found");
+  result = it->value.get();
+  return Response::OK();
 }
 
-void InspectorLayerTreeAgent::replaySnapshot(ErrorString* errorString,
-                                             const String& snapshotId,
-                                             const Maybe<int>& fromStep,
-                                             const Maybe<int>& toStep,
-                                             const Maybe<double>& scale,
-                                             String* dataURL) {
-  const PictureSnapshot* snapshot = snapshotById(errorString, snapshotId);
-  if (!snapshot)
-    return;
+Response InspectorLayerTreeAgent::replaySnapshot(const String& snapshotId,
+                                                 Maybe<int> fromStep,
+                                                 Maybe<int> toStep,
+                                                 Maybe<double> scale,
+                                                 String* dataURL) {
+  const PictureSnapshot* snapshot = nullptr;
+  Response response = snapshotById(snapshotId, snapshot);
+  if (!response.isSuccess())
+    return response;
   std::unique_ptr<Vector<char>> base64Data = snapshot->replay(
       fromStep.fromMaybe(0), toStep.fromMaybe(0), scale.fromMaybe(1.0));
-  if (!base64Data) {
-    *errorString = "Image encoding failed";
-    return;
-  }
+  if (!base64Data)
+    return Response::Error("Image encoding failed");
   StringBuilder url;
   url.append("data:image/png;base64,");
   url.reserveCapacity(url.length() + base64Data->size());
   url.append(base64Data->begin(), base64Data->size());
   *dataURL = url.toString();
+  return Response::OK();
 }
 
 static void parseRect(protocol::DOM::Rect* object, FloatRect* rect) {
   *rect = FloatRect(object->getX(), object->getY(), object->getWidth(),
                     object->getHeight());
 }
 
-void InspectorLayerTreeAgent::profileSnapshot(
-    ErrorString* errorString,
+Response InspectorLayerTreeAgent::profileSnapshot(
     const String& snapshotId,
-    const protocol::Maybe<int>& minRepeatCount,
-    const protocol::Maybe<double>& minDuration,
-    const Maybe<protocol::DOM::Rect>& clipRect,
+    Maybe<int> minRepeatCount,
+    Maybe<double> minDuration,
+    Maybe<protocol::DOM::Rect> clipRect,
     std::unique_ptr<protocol::Array<protocol::Array<double>>>* outTimings) {
-  const PictureSnapshot* snapshot = snapshotById(errorString, snapshotId);
-  if (!snapshot)
-    return;
+  const PictureSnapshot* snapshot = nullptr;
+  Response response = snapshotById(snapshotId, snapshot);
+  if (!response.isSuccess())
+    return response;
   FloatRect rect;
   if (clipRect.isJust())
     parseRect(clipRect.fromJust(), &rect);
   std::unique_ptr<PictureSnapshot::Timings> timings =
       snapshot->profile(minRepeatCount.fromMaybe(1), minDuration.fromMaybe(0),
                         clipRect.isJust() ? &rect : 0);
   *outTimings = Array<Array<double>>::create();
   for (size_t i = 0; i < timings->size(); ++i) {
     const Vector<double>& row = (*timings)[i];
     std::unique_ptr<Array<double>> outRow = Array<double>::create();
     for (size_t j = 0; j < row.size(); ++j)
       outRow->addItem(row[j]);
     (*outTimings)->addItem(std::move(outRow));
   }
+  return Response::OK();
 }
 
-void InspectorLayerTreeAgent::snapshotCommandLog(
-    ErrorString* errorString,
+Response InspectorLayerTreeAgent::snapshotCommandLog(
     const String& snapshotId,
     std::unique_ptr<Array<protocol::DictionaryValue>>* commandLog) {
-  const PictureSnapshot* snapshot = snapshotById(errorString, snapshotId);
-  if (!snapshot)
-    return;
-  protocol::ErrorSupport errors(errorString);
+  const PictureSnapshot* snapshot = nullptr;
+  Response response = snapshotById(snapshotId, snapshot);
+  if (!response.isSuccess())
+    return response;
+  protocol::ErrorSupport errors;
   std::unique_ptr<protocol::Value> logValue =
       protocol::parseJSON(snapshot->snapshotCommandLog()->toJSONString());
   *commandLog =
       Array<protocol::DictionaryValue>::parse(logValue.get(), &errors);
+  if (errors.hasErrors())
+    return Response::Error(errors.errors());
+  return Response::OK();
 }
 
 void InspectorLayerTreeAgent::willAddPageOverlay(const GraphicsLayer* layer) {
   m_pageOverlayLayerIds.append(layer->platformLayer()->id());
 }
 
 void InspectorLayerTreeAgent::didRemovePageOverlay(const GraphicsLayer* layer) {
   size_t index = m_pageOverlayLayerIds.find(layer->platformLayer()->id());
   if (index == WTF::kNotFound)
     return;
   m_pageOverlayLayerIds.remove(index);
 }
 
 }  // namespace blink