Avoid naming conflict for Cache and Response in cachestorage

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 <algorithm>
 #include <memory>
 #include <utility>
 #include "platform/heap/Handle.h"
@@ skipping 12 matching lines @@
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCache.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCacheError.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerCacheStorage.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 
 using blink::protocol::Array;
-using blink::protocol::CacheStorage::Cache;
+// Renaming Cache since there is another blink::Cache.
+using ProtocolCache = blink::protocol::CacheStorage::Cache;
 using blink::protocol::CacheStorage::DataEntry;
-using blink::protocol::Response;
+// Renaming Response since there is another blink::Response.
+using ProtocolResponse = blink::protocol::Response;
 
 typedef blink::protocol::CacheStorage::Backend::DeleteCacheCallback
     DeleteCacheCallback;
 typedef blink::protocol::CacheStorage::Backend::DeleteEntryCallback
     DeleteEntryCallback;
 typedef blink::protocol::CacheStorage::Backend::RequestCacheNamesCallback
     RequestCacheNamesCallback;
 typedef blink::protocol::CacheStorage::Backend::RequestEntriesCallback
     RequestEntriesCallback;
 typedef blink::WebServiceWorkerCache::BatchOperation BatchOperation;
 
 namespace blink {
 
 namespace {
 
 String BuildCacheId(const String& security_origin, const String& cache_name) {
   String id(security_origin);
   id.append('|');
   id.append(cache_name);
   return id;
 }
 
-Response ParseCacheId(const String& id,
-                      String* security_origin,
-                      String* cache_name) {
+ProtocolResponse ParseCacheId(const String& id,
+                              String* security_origin,
+                              String* cache_name) {
   size_t pipe = id.find('|');
   if (pipe == WTF::kNotFound)
-    return Response::Error("Invalid cache id.");
+    return ProtocolResponse::Error("Invalid cache id.");
   *security_origin = id.Substring(0, pipe);
   *cache_name = id.Substring(pipe + 1);
-  return Response::OK();
+  return ProtocolResponse::OK();
 }
 
-Response AssertCacheStorage(
+ProtocolResponse AssertCacheStorage(
     const String& security_origin,
     std::unique_ptr<WebServiceWorkerCacheStorage>& result) {
   RefPtr<SecurityOrigin> sec_origin =
       SecurityOrigin::CreateFromString(security_origin);
 
   // Cache Storage API is restricted to trustworthy origins.
-  if (!sec_origin->IsPotentiallyTrustworthy())
-    return Response::Error(sec_origin->IsPotentiallyTrustworthyErrorMessage());
+  if (!sec_origin->IsPotentiallyTrustworthy()) {
+    return ProtocolResponse::Error(
+        sec_origin->IsPotentiallyTrustworthyErrorMessage());
+  }
 
   std::unique_ptr<WebServiceWorkerCacheStorage> cache =
       Platform::Current()->CreateCacheStorage(WebSecurityOrigin(sec_origin));
   if (!cache)
-    return Response::Error("Could not find cache storage.");
+    return ProtocolResponse::Error("Could not find cache storage.");
   result = std::move(cache);
-  return Response::OK();
+  return ProtocolResponse::OK();
 }
 
-Response AssertCacheStorageAndNameForId(
+ProtocolResponse AssertCacheStorageAndNameForId(
     const String& cache_id,
     String* cache_name,
     std::unique_ptr<WebServiceWorkerCacheStorage>& result) {
   String security_origin;
-  Response response = ParseCacheId(cache_id, &security_origin, cache_name);
+  ProtocolResponse response =
+      ParseCacheId(cache_id, &security_origin, cache_name);
   if (!response.isSuccess())
     return response;
   return AssertCacheStorage(security_origin, result);
 }
 
 CString ServiceWorkerCacheErrorString(WebServiceWorkerCacheError error) {
   switch (error) {
     case kWebServiceWorkerCacheErrorNotImplemented:
       return CString("not implemented.");
       break;
@@ skipping 19 matching lines @@
   WTF_MAKE_NONCOPYABLE(RequestCacheNames);
 
  public:
   RequestCacheNames(const String& security_origin,
                     std::unique_ptr<RequestCacheNamesCallback> callback)
       : security_origin_(security_origin), callback_(std::move(callback)) {}
 
   ~RequestCacheNames() override {}
 
   void OnSuccess(const WebVector<WebString>& caches) override {
-    std::unique_ptr<Array<Cache>> array = Array<Cache>::create();
+    std::unique_ptr<Array<ProtocolCache>> array =
+        Array<ProtocolCache>::create();
     for (size_t i = 0; i < caches.size(); i++) {
       String name = String(caches[i]);
-      std::unique_ptr<Cache> entry =
-          Cache::create()
+      std::unique_ptr<ProtocolCache> entry =
+          ProtocolCache::create()
               .setSecurityOrigin(security_origin_)
               .setCacheName(name)
               .setCacheId(BuildCacheId(security_origin_, name))
               .build();
       array->addItem(std::move(entry));
     }
     callback_->sendSuccess(std::move(array));
   }
 
   void OnError(WebServiceWorkerCacheError error) override {
-    callback_->sendFailure(Response::Error(
+    callback_->sendFailure(ProtocolResponse::Error(
         String::Format("Error requesting cache names: %s",
                        ServiceWorkerCacheErrorString(error).data())));
   }
 
  private:
   String security_origin_;
   std::unique_ptr<RequestCacheNamesCallback> callback_;
 };
 
 struct DataRequestParams {
@@ skipping 53 matching lines @@
           DataEntry::create()
               .setRequest(request_response.request)
               .setResponse(request_response.response)
               .setResponseTime(request_response.response_time)
               .build();
       array->addItem(std::move(entry));
     }
     callback_->sendSuccess(std::move(array), has_more);
   }
 
-  void SendFailure(const Response& error) { callback_->sendFailure(error); }
+  void SendFailure(const ProtocolResponse& error) {
+    callback_->sendFailure(error);
+  }
 
  private:
   DataRequestParams params_;
   int num_responses_left_;
   Vector<RequestResponse> responses_;
   std::unique_ptr<RequestEntriesCallback> callback_;
 };
 
 class GetCacheResponsesForRequestData
     : public WebServiceWorkerCache::CacheMatchCallbacks {
   WTF_MAKE_NONCOPYABLE(GetCacheResponsesForRequestData);
 
  public:
   GetCacheResponsesForRequestData(const DataRequestParams& params,
                                   const WebServiceWorkerRequest& request,
                                   PassRefPtr<ResponsesAccumulator> accum)
       : params_(params), request_(request), accumulator_(std::move(accum)) {}
   ~GetCacheResponsesForRequestData() override {}
 
   void OnSuccess(const WebServiceWorkerResponse& response) override {
     accumulator_->AddRequestResponsePair(request_, response);
   }
 
   void OnError(WebServiceWorkerCacheError error) override {
-    accumulator_->SendFailure(Response::Error(
+    accumulator_->SendFailure(ProtocolResponse::Error(
         String::Format("Error requesting responses for cache  %s: %s",
                        params_.cache_name.Utf8().data(),
                        ServiceWorkerCacheErrorString(error).data())));
   }
 
  private:
   DataRequestParams params_;
   WebServiceWorkerRequest request_;
   RefPtr<ResponsesAccumulator> accumulator_;
 };
@@ skipping 25 matching lines @@
     for (size_t i = 0; i < requests.size(); i++) {
       const auto& request = requests[i];
       auto cache_request = WTF::MakeUnique<GetCacheResponsesForRequestData>(
           params_, request, accumulator);
       cache_->DispatchMatch(std::move(cache_request), request,
                             WebServiceWorkerCache::QueryParams());
     }
   }
 
   void OnError(WebServiceWorkerCacheError error) override {
-    callback_->sendFailure(Response::Error(
+    callback_->sendFailure(ProtocolResponse::Error(
         String::Format("Error requesting requests for cache %s: %s",
                        params_.cache_name.Utf8().data(),
                        ServiceWorkerCacheErrorString(error).data())));
   }
 
  private:
   DataRequestParams params_;
   std::unique_ptr<WebServiceWorkerCache> cache_;
   std::unique_ptr<RequestEntriesCallback> callback_;
 };
@@ skipping 10 matching lines @@
 
   void OnSuccess(std::unique_ptr<WebServiceWorkerCache> cache) override {
     auto cache_request = WTF::MakeUnique<GetCacheKeysForRequestData>(
         params_, std::move(cache), std::move(callback_));
     cache_request->Cache()->DispatchKeys(std::move(cache_request),
                                          WebServiceWorkerRequest(),
                                          WebServiceWorkerCache::QueryParams());
   }
 
   void OnError(WebServiceWorkerCacheError error) override {
-    callback_->sendFailure(Response::Error(String::Format(
+    callback_->sendFailure(ProtocolResponse::Error(String::Format(
         "Error requesting cache %s: %s", params_.cache_name.Utf8().data(),
         ServiceWorkerCacheErrorString(error).data())));
   }
 
  private:
   DataRequestParams params_;
   std::unique_ptr<RequestEntriesCallback> callback_;
 };
 
 class DeleteCache : public WebServiceWorkerCacheStorage::CacheStorageCallbacks {
   WTF_MAKE_NONCOPYABLE(DeleteCache);
 
  public:
   DeleteCache(std::unique_ptr<DeleteCacheCallback> callback)
       : callback_(std::move(callback)) {}
   ~DeleteCache() override {}
 
   void OnSuccess() override { callback_->sendSuccess(); }
 
   void OnError(WebServiceWorkerCacheError error) override {
-    callback_->sendFailure(Response::Error(
+    callback_->sendFailure(ProtocolResponse::Error(
         String::Format("Error requesting cache names: %s",
                        ServiceWorkerCacheErrorString(error).data())));
   }
 
  private:
   std::unique_ptr<DeleteCacheCallback> callback_;
 };
 
 class DeleteCacheEntry : public WebServiceWorkerCache::CacheBatchCallbacks {
   WTF_MAKE_NONCOPYABLE(DeleteCacheEntry);
 
  public:
   DeleteCacheEntry(std::unique_ptr<DeleteEntryCallback> callback)
       : callback_(std::move(callback)) {}
   ~DeleteCacheEntry() override {}
 
   void OnSuccess() override { callback_->sendSuccess(); }
 
   void OnError(WebServiceWorkerCacheError error) override {
-    callback_->sendFailure(Response::Error(
+    callback_->sendFailure(ProtocolResponse::Error(
         String::Format("Error requesting cache names: %s",
                        ServiceWorkerCacheErrorString(error).data())));
   }
 
  private:
   std::unique_ptr<DeleteEntryCallback> callback_;
 };
 
 class GetCacheForDeleteEntry
     : public WebServiceWorkerCacheStorage::CacheStorageWithCacheCallbacks {
@@ skipping 15 matching lines @@
     delete_operation.operation_type =
         WebServiceWorkerCache::kOperationTypeDelete;
     delete_operation.request.SetURL(KURL(kParsedURLString, request_spec_));
     Vector<BatchOperation> operations;
     operations.push_back(delete_operation);
     cache.release()->DispatchBatch(std::move(delete_request),
                                    WebVector<BatchOperation>(operations));
   }
 
   void OnError(WebServiceWorkerCacheError error) override {
-    callback_->sendFailure(Response::Error(String::Format(
+    callback_->sendFailure(ProtocolResponse::Error(String::Format(
         "Error requesting cache %s: %s", cache_name_.Utf8().data(),
         ServiceWorkerCacheErrorString(error).data())));
   }
 
  private:
   String request_spec_;
   String cache_name_;
   std::unique_ptr<DeleteEntryCallback> callback_;
 };
 
@@ skipping 10 matching lines @@
 void InspectorCacheStorageAgent::requestCacheNames(
     const String& security_origin,
     std::unique_ptr<RequestCacheNamesCallback> callback) {
   RefPtr<SecurityOrigin> sec_origin =
       SecurityOrigin::CreateFromString(security_origin);
 
   // Cache Storage API is restricted to trustworthy origins.
   if (!sec_origin->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());
+    callback->sendSuccess(Array<ProtocolCache>::create());
     return;
   }
 
   std::unique_ptr<WebServiceWorkerCacheStorage> cache;
-  Response response = AssertCacheStorage(security_origin, cache);
+  ProtocolResponse response = AssertCacheStorage(security_origin, cache);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
   cache->DispatchKeys(
       WTF::MakeUnique<RequestCacheNames>(security_origin, std::move(callback)));
 }
 
 void InspectorCacheStorageAgent::requestEntries(
     const String& cache_id,
     int skip_count,
     int page_size,
     std::unique_ptr<RequestEntriesCallback> callback) {
   String cache_name;
   std::unique_ptr<WebServiceWorkerCacheStorage> cache;
-  Response response =
+  ProtocolResponse response =
       AssertCacheStorageAndNameForId(cache_id, &cache_name, cache);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
   DataRequestParams params;
   params.cache_name = cache_name;
   params.page_size = page_size;
   params.skip_count = skip_count;
   cache->DispatchOpen(
       WTF::MakeUnique<GetCacheForRequestData>(params, std::move(callback)),
       WebString(cache_name));
 }
 
 void InspectorCacheStorageAgent::deleteCache(
     const String& cache_id,
     std::unique_ptr<DeleteCacheCallback> callback) {
   String cache_name;
   std::unique_ptr<WebServiceWorkerCacheStorage> cache;
-  Response response =
+  ProtocolResponse response =
       AssertCacheStorageAndNameForId(cache_id, &cache_name, cache);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
   cache->DispatchDelete(WTF::MakeUnique<DeleteCache>(std::move(callback)),
                         WebString(cache_name));
 }
 
 void InspectorCacheStorageAgent::deleteEntry(
     const String& cache_id,
     const String& request,
     std::unique_ptr<DeleteEntryCallback> callback) {
   String cache_name;
   std::unique_ptr<WebServiceWorkerCacheStorage> cache;
-  Response response =
+  ProtocolResponse response =
       AssertCacheStorageAndNameForId(cache_id, &cache_name, cache);
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
   cache->DispatchOpen(WTF::MakeUnique<GetCacheForDeleteEntry>(
                           request, cache_name, std::move(callback)),
                       WebString(cache_name));
 }
 
 }  // namespace blink