[DevTools] migrate Database, IndexedDB and CacheStorage to new style

third_party/WebKit/Source/modules/cachestorage/InspectorCacheStorageAgent.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/cachestorage/InspectorCacheStorageAgent.h"
 
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
@@ skipping 34 matching lines @@
 
 namespace {
 
 String buildCacheId(const String& securityOrigin, const String& cacheName) {
   String id(securityOrigin);
   id.append('|');
   id.append(cacheName);
   return id;
 }
 
-bool parseCacheId(ErrorString* errorString,
-                  const String& id,
-                  String* securityOrigin,
-                  String* cacheName) {
+Response parseCacheId(const String& id,
+                      String* securityOrigin,
+                      String* cacheName) {
   size_t pipe = id.find('|');
-  if (pipe == WTF::kNotFound) {
-    *errorString = "Invalid cache id.";
-    return false;
-  }
+  if (pipe == WTF::kNotFound)
+    return Response::Error("Invalid cache id.");
   *securityOrigin = id.substring(0, pipe);
   *cacheName = id.substring(pipe + 1);
-  return true;
+  return Response::OK();
 }
 
-std::unique_ptr<WebServiceWorkerCacheStorage> assertCacheStorage(
-    ErrorString* errorString,
-    const String& securityOrigin) {
+Response assertCacheStorage(
+    const String& securityOrigin,
+    std::unique_ptr<WebServiceWorkerCacheStorage>& result) {
   RefPtr<SecurityOrigin> secOrigin =
       SecurityOrigin::createFromString(securityOrigin);
 
   // Cache Storage API is restricted to trustworthy origins.
-  if (!secOrigin->isPotentiallyTrustworthy()) {
-    *errorString = secOrigin->isPotentiallyTrustworthyErrorMessage();
-    return nullptr;
-  }
+  if (!secOrigin->isPotentiallyTrustworthy())
+    return Response::Error(secOrigin->isPotentiallyTrustworthyErrorMessage());
 
   std::unique_ptr<WebServiceWorkerCacheStorage> cache = wrapUnique(
       Platform::current()->cacheStorage(WebSecurityOrigin(secOrigin)));
   if (!cache)
-    *errorString = "Could not find cache storage.";
-  return cache;
+    return Response::Error("Could not find cache storage.");
+  result = std::move(cache);
+  return Response::OK();
 }
 
-std::unique_ptr<WebServiceWorkerCacheStorage> assertCacheStorageAndNameForId(
-    ErrorString* errorString,
+Response assertCacheStorageAndNameForId(
     const String& cacheId,
-    String* cacheName) {
+    String* cacheName,
+    std::unique_ptr<WebServiceWorkerCacheStorage>& result) {
   String securityOrigin;
-  if (!parseCacheId(errorString, cacheId, &securityOrigin, cacheName)) {
-    return nullptr;
-  }
-  return assertCacheStorage(errorString, securityOrigin);
+  Response response = parseCacheId(cacheId, &securityOrigin, cacheName);
+  if (!response.isSuccess())
+    return response;
+  return assertCacheStorage(securityOrigin, result);
 }
 
 CString serviceWorkerCacheErrorString(WebServiceWorkerCacheError error) {
   switch (error) {
     case WebServiceWorkerCacheErrorNotImplemented:
       return CString("not implemented.");
       break;
     case WebServiceWorkerCacheErrorNotFound:
       return CString("not found.");
       break;
@@ skipping 31 matching lines @@
               .setSecurityOrigin(m_securityOrigin)
               .setCacheName(name)
               .setCacheId(buildCacheId(m_securityOrigin, name))
               .build();
       array->addItem(std::move(entry));
     }
     m_callback->sendSuccess(std::move(array));
   }
 
   void onError(WebServiceWorkerCacheError error) override {
-    m_callback->sendFailure(
+    m_callback->sendFailure(Response::Error(
         String::format("Error requesting cache names: %s",
-                       serviceWorkerCacheErrorString(error).data()));
+                       serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
   String m_securityOrigin;
   std::unique_ptr<RequestCacheNamesCallback> m_callback;
 };
 
 struct DataRequestParams {
   String cacheName;
   int skipCount;
@@ skipping 48 matching lines @@
       std::unique_ptr<DataEntry> entry =
           DataEntry::create()
               .setRequest(requestResponse.request)
               .setResponse(requestResponse.response)
               .build();
       array->addItem(std::move(entry));
     }
     m_callback->sendSuccess(std::move(array), hasMore);
   }
 
-  void sendFailure(const String& error) { m_callback->sendFailure(error); }
+  void sendFailure(const Response& error) { m_callback->sendFailure(error); }
 
  private:
   DataRequestParams m_params;
   int m_numResponsesLeft;
   Vector<RequestResponse> m_responses;
   std::unique_ptr<RequestEntriesCallback> m_callback;
 };
 
 class GetCacheResponsesForRequestData
     : public WebServiceWorkerCache::CacheMatchCallbacks {
   WTF_MAKE_NONCOPYABLE(GetCacheResponsesForRequestData);
 
  public:
   GetCacheResponsesForRequestData(const DataRequestParams& params,
                                   const WebServiceWorkerRequest& request,
                                   PassRefPtr<ResponsesAccumulator> accum)
       : m_params(params), m_request(request), m_accumulator(accum) {}
   ~GetCacheResponsesForRequestData() override {}
 
   void onSuccess(const WebServiceWorkerResponse& response) override {
     m_accumulator->addRequestResponsePair(m_request, response);
   }
 
   void onError(WebServiceWorkerCacheError error) override {
-    m_accumulator->sendFailure(
+    m_accumulator->sendFailure(Response::Error(
         String::format("Error requesting responses for cache  %s: %s",
                        m_params.cacheName.utf8().data(),
-                       serviceWorkerCacheErrorString(error).data()));
+                       serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
   DataRequestParams m_params;
   WebServiceWorkerRequest m_request;
   RefPtr<ResponsesAccumulator> m_accumulator;
 };
 
 class GetCacheKeysForRequestData
     : public WebServiceWorkerCache::CacheWithRequestsCallbacks {
@@ skipping 22 matching lines @@
     for (size_t i = 0; i < requests.size(); i++) {
       const auto& request = requests[i];
       auto* cacheRequest =
           new GetCacheResponsesForRequestData(m_params, request, accumulator);
       m_cache->dispatchMatch(cacheRequest, request,
                              WebServiceWorkerCache::QueryParams());
     }
   }
 
   void onError(WebServiceWorkerCacheError error) override {
-    m_callback->sendFailure(
+    m_callback->sendFailure(Response::Error(
         String::format("Error requesting requests for cache %s: %s",
                        m_params.cacheName.utf8().data(),
-                       serviceWorkerCacheErrorString(error).data()));
+                       serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
   DataRequestParams m_params;
   std::unique_ptr<WebServiceWorkerCache> m_cache;
   std::unique_ptr<RequestEntriesCallback> m_callback;
 };
 
 class GetCacheForRequestData
     : public WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks {
   WTF_MAKE_NONCOPYABLE(GetCacheForRequestData);
 
  public:
   GetCacheForRequestData(const DataRequestParams& params,
                          std::unique_ptr<RequestEntriesCallback> callback)
       : m_params(params), m_callback(std::move(callback)) {}
   ~GetCacheForRequestData() override {}
 
   void onSuccess(std::unique_ptr<WebServiceWorkerCache> cache) override {
     auto* cacheRequest = new GetCacheKeysForRequestData(
         m_params, wrapUnique(cache.release()), std::move(m_callback));
     cacheRequest->cache()->dispatchKeys(cacheRequest, WebServiceWorkerRequest(),
                                         WebServiceWorkerCache::QueryParams());
   }
 
   void onError(WebServiceWorkerCacheError error) override {
-    m_callback->sendFailure(String::format(
+    m_callback->sendFailure(Response::Error(String::format(
         "Error requesting cache %s: %s", m_params.cacheName.utf8().data(),
-        serviceWorkerCacheErrorString(error).data()));
+        serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
   DataRequestParams m_params;
   std::unique_ptr<RequestEntriesCallback> m_callback;
 };
 
 class DeleteCache : public WebServiceWorkerCacheStorage::CacheStorageCallbacks {
   WTF_MAKE_NONCOPYABLE(DeleteCache);
 
  public:
   DeleteCache(std::unique_ptr<DeleteCacheCallback> callback)
       : m_callback(std::move(callback)) {}
   ~DeleteCache() override {}
 
   void onSuccess() override { m_callback->sendSuccess(); }
 
   void onError(WebServiceWorkerCacheError error) override {
-    m_callback->sendFailure(
+    m_callback->sendFailure(Response::Error(
         String::format("Error requesting cache names: %s",
-                       serviceWorkerCacheErrorString(error).data()));
+                       serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
   std::unique_ptr<DeleteCacheCallback> m_callback;
 };
 
 class DeleteCacheEntry : public WebServiceWorkerCache::CacheBatchCallbacks {
   WTF_MAKE_NONCOPYABLE(DeleteCacheEntry);
 
  public:
   DeleteCacheEntry(std::unique_ptr<DeleteEntryCallback> callback)
       : m_callback(std::move(callback)) {}
   ~DeleteCacheEntry() override {}
 
   void onSuccess() override { m_callback->sendSuccess(); }
 
   void onError(WebServiceWorkerCacheError error) override {
-    m_callback->sendFailure(
+    m_callback->sendFailure(Response::Error(
         String::format("Error requesting cache names: %s",
-                       serviceWorkerCacheErrorString(error).data()));
+                       serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
   std::unique_ptr<DeleteEntryCallback> m_callback;
 };
 
 class GetCacheForDeleteEntry
     : public WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks {
   WTF_MAKE_NONCOPYABLE(GetCacheForDeleteEntry);
 
@@ skipping 11 matching lines @@
     BatchOperation deleteOperation;
     deleteOperation.operationType = WebServiceWorkerCache::OperationTypeDelete;
     deleteOperation.request.setURL(KURL(ParsedURLString, m_requestSpec));
     Vector<BatchOperation> operations;
     operations.append(deleteOperation);
     cache.release()->dispatchBatch(deleteRequest,
                                    WebVector<BatchOperation>(operations));
   }
 
   void onError(WebServiceWorkerCacheError error) override {
-    m_callback->sendFailure(String::format(
+    m_callback->sendFailure(Response::Error(String::format(
         "Error requesting cache %s: %s", m_cacheName.utf8().data(),
-        serviceWorkerCacheErrorString(error).data()));
+        serviceWorkerCacheErrorString(error).data())));
   }
 
  private:
   String m_requestSpec;
   String m_cacheName;
   std::unique_ptr<DeleteEntryCallback> m_callback;
 };
 
 }  // namespace
 
@@ skipping 12 matching lines @@
       SecurityOrigin::createFromString(securityOrigin);
 
   // Cache Storage API is restricted to trustworthy origins.
   if (!secOrigin->isPotentiallyTrustworthy()) {
     // Don't treat this as an error, just don't attempt to open and enumerate
     // the caches.
     callback->sendSuccess(Array<protocol::CacheStorage::Cache>::create());
     return;
   }
 
-  ErrorString errorString;
-  std::unique_ptr<WebServiceWorkerCacheStorage> cache =
-      assertCacheStorage(&errorString, securityOrigin);
-  if (!cache) {
-    callback->sendFailure(errorString);
+  std::unique_ptr<WebServiceWorkerCacheStorage> cache;
+  Response response = assertCacheStorage(securityOrigin, cache);
+  if (!response.isSuccess()) {
+    callback->sendFailure(response);
     return;
   }
   cache->dispatchKeys(
       new RequestCacheNames(securityOrigin, std::move(callback)));
 }
 
 void InspectorCacheStorageAgent::requestEntries(
     const String& cacheId,
     int skipCount,
     int pageSize,
     std::unique_ptr<RequestEntriesCallback> callback) {
-  ErrorString errorString;
   String cacheName;
-  std::unique_ptr<WebServiceWorkerCacheStorage> cache =
-      assertCacheStorageAndNameForId(&errorString, cacheId, &cacheName);
-  if (!cache) {
-    callback->sendFailure(errorString);
+  std::unique_ptr<WebServiceWorkerCacheStorage> cache;
+  Response response =
+      assertCacheStorageAndNameForId(cacheId, &cacheName, cache);
+  if (!response.isSuccess()) {
+    callback->sendFailure(response);
     return;
   }
   DataRequestParams params;
   params.cacheName = cacheName;
   params.pageSize = pageSize;
   params.skipCount = skipCount;
   cache->dispatchOpen(new GetCacheForRequestData(params, std::move(callback)),
                       WebString(cacheName));
 }
 
 void InspectorCacheStorageAgent::deleteCache(
     const String& cacheId,
     std::unique_ptr<DeleteCacheCallback> callback) {
   String cacheName;
-  ErrorString errorString;
-  std::unique_ptr<WebServiceWorkerCacheStorage> cache =
-      assertCacheStorageAndNameForId(&errorString, cacheId, &cacheName);
-  if (!cache) {
-    callback->sendFailure(errorString);
+  std::unique_ptr<WebServiceWorkerCacheStorage> cache;
+  Response response =
+      assertCacheStorageAndNameForId(cacheId, &cacheName, cache);
+  if (!response.isSuccess()) {
+    callback->sendFailure(response);
     return;
   }
   cache->dispatchDelete(new DeleteCache(std::move(callback)),
                         WebString(cacheName));
 }
 
 void InspectorCacheStorageAgent::deleteEntry(
     const String& cacheId,
     const String& request,
     std::unique_ptr<DeleteEntryCallback> callback) {
   String cacheName;
-  ErrorString errorString;
-  std::unique_ptr<WebServiceWorkerCacheStorage> cache =
-      assertCacheStorageAndNameForId(&errorString, cacheId, &cacheName);
-  if (!cache) {
-    callback->sendFailure(errorString);
+  std::unique_ptr<WebServiceWorkerCacheStorage> cache;
+  Response response =
+      assertCacheStorageAndNameForId(cacheId, &cacheName, cache);
+  if (!response.isSuccess()) {
+    callback->sendFailure(response);
     return;
   }
   cache->dispatchOpen(
       new GetCacheForDeleteEntry(request, cacheName, std::move(callback)),
       WebString(cacheName));
 }
 
 }  // namespace blink