blink: Rename modules/ method to prefix with get when they collide.

third_party/WebKit/Source/modules/cachestorage/Cache.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/Cache.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 31 matching lines @@
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheMatchCallbacks : public WebServiceWorkerCache::CacheMatchCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheMatchCallbacks);
 public:
     explicit CacheMatchCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
     void onSuccess(const WebServiceWorkerResponse& webResponse) override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
-        m_resolver->resolve(Response::create(m_resolver->scriptState()->executionContext(), webResponse));
+        m_resolver->resolve(Response::create(m_resolver->getScriptState()->getExecutionContext(), webResponse));
         m_resolver.clear();
     }
 
     void onError(WebServiceWorkerCacheError reason) override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         if (reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve();
         else
             m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
 private:
     Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheWithResponsesCallbacks : public WebServiceWorkerCache::CacheWithResponsesCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheWithResponsesCallbacks);
 public:
     explicit CacheWithResponsesCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
     void onSuccess(const WebVector<WebServiceWorkerResponse>& webResponses) override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         HeapVector<Member<Response>> responses;
         for (size_t i = 0; i < webResponses.size(); ++i)
-            responses.append(Response::create(m_resolver->scriptState()->executionContext(), webResponses[i]));
+            responses.append(Response::create(m_resolver->getScriptState()->getExecutionContext(), webResponses[i]));
         m_resolver->resolve(responses);
         m_resolver.clear();
     }
 
     void onError(WebServiceWorkerCacheError reason) override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
 protected:
     Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheDeleteCallback : public WebServiceWorkerCache::CacheBatchCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheDeleteCallback);
 public:
     explicit CacheDeleteCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
     void onSuccess() override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->resolve(true);
         m_resolver.clear();
     }
 
     void onError(WebServiceWorkerCacheError reason) override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         if (reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve(false);
         else
             m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
 private:
     Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheWithRequestsCallbacks : public WebServiceWorkerCache::CacheWithRequestsCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheWithRequestsCallbacks);
 public:
     explicit CacheWithRequestsCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
     void onSuccess(const WebVector<WebServiceWorkerRequest>& webRequests) override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         HeapVector<Member<Request>> requests;
         for (size_t i = 0; i < webRequests.size(); ++i)
-            requests.append(Request::create(m_resolver->scriptState()->executionContext(), webRequests[i]));
+            requests.append(Request::create(m_resolver->getScriptState()->getExecutionContext(), webRequests[i]));
         m_resolver->resolve(requests);
         m_resolver.clear();
     }
 
     void onError(WebServiceWorkerCacheError reason) override
     {
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->reject(CacheStorageError::createException(reason));
         m_resolver.clear();
     }
 
 private:
     Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // Used for UMA. Append only.
@@ skipping 59 matching lines @@
 public:
     static v8::Local<v8::Function> create(ScriptState* scriptState, Cache* cache, const HeapVector<Member<Request>>& requests)
     {
         FetchResolvedForAdd* self = new FetchResolvedForAdd(scriptState, cache, requests);
         return self->bindToV8Function();
     }
 
     ScriptValue call(ScriptValue value) override
     {
         NonThrowableExceptionState exceptionState;
-        HeapVector<Member<Response>> responses = toMemberNativeArray<Response, V8Response>(value.v8Value(), m_requests.size(), scriptState()->isolate(), exceptionState);
+        HeapVector<Member<Response>> responses = toMemberNativeArray<Response, V8Response>(value.v8Value(), m_requests.size(), getScriptState()->isolate(), exceptionState);
 
         for (const auto& response : responses) {
             if (!response->ok()) {
-                ScriptPromise rejection = ScriptPromise::reject(scriptState(), V8ThrowException::createTypeError(scriptState()->isolate(), "Request failed"));
-                return ScriptValue(scriptState(), rejection.v8Value());
+                ScriptPromise rejection = ScriptPromise::reject(getScriptState(), V8ThrowException::createTypeError(getScriptState()->isolate(), "Request failed"));
+                return ScriptValue(getScriptState(), rejection.v8Value());
             }
             if (varyHeaderContainsAsterisk(response)) {
-                ScriptPromise rejection = ScriptPromise::reject(scriptState(), V8ThrowException::createTypeError(scriptState()->isolate(), "Vary header contains *"));
-                return ScriptValue(scriptState(), rejection.v8Value());
+                ScriptPromise rejection = ScriptPromise::reject(getScriptState(), V8ThrowException::createTypeError(getScriptState()->isolate(), "Vary header contains *"));
+                return ScriptValue(getScriptState(), rejection.v8Value());
             }
         }
 
         for (const auto& response : responses)
             RecordResponseTypeForAdd(response);
 
-        ScriptPromise putPromise = m_cache->putImpl(scriptState(), m_requests, responses);
-        return ScriptValue(scriptState(), putPromise.v8Value());
+        ScriptPromise putPromise = m_cache->putImpl(getScriptState(), m_requests, responses);
+        return ScriptValue(getScriptState(), putPromise.v8Value());
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_cache);
         visitor->trace(m_requests);
         ScriptFunction::trace(visitor);
     }
 
 private:
@@ skipping 17 matching lines @@
     {
         ASSERT(0 < m_numberOfRemainingOperations);
         m_batchOperations.resize(numberOfOperations);
     }
 
     void onSuccess(size_t index, const WebServiceWorkerCache::BatchOperation& batchOperation)
     {
         ASSERT(index < m_batchOperations.size());
         if (m_completed)
             return;
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
         m_batchOperations[index] = batchOperation;
         if (--m_numberOfRemainingOperations != 0)
             return;
         m_cache->webCache()->dispatchBatch(new CallbackPromiseAdapter<void, CacheStorageError>(m_resolver), m_batchOperations);
     }
 
     void onError(const String& errorMessage)
     {
         if (m_completed)
             return;
         m_completed = true;
-        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
+        if (!m_resolver->getExecutionContext() || m_resolver->getExecutionContext()->activeDOMObjectsAreStopped())
             return;
-        ScriptState* state = m_resolver->scriptState();
+        ScriptState* state = m_resolver->getScriptState();
         ScriptState::Scope scope(state);
         m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), errorMessage));
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_cache);
         visitor->trace(m_resolver);
     }
 
@@ skipping 166 matching lines @@
 
 DEFINE_TRACE(Cache)
 {
     visitor->trace(m_scopedFetcher);
 }
 
 ScriptPromise Cache::matchImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
-    checkCacheQueryOptions(options, scriptState->executionContext());
+    checkCacheQueryOptions(options, scriptState->getExecutionContext());
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchMatch(new CacheMatchCallbacks(resolver), webRequest, toWebQueryParams(options));
     return promise;
 }
 
 ScriptPromise Cache::matchAllImpl(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver), WebServiceWorkerRequest(), WebServiceWorkerCache::QueryParams());
     return promise;
 }
 
 ScriptPromise Cache::matchAllImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
-    checkCacheQueryOptions(options, scriptState->executionContext());
+    checkCacheQueryOptions(options, scriptState->getExecutionContext());
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver), webRequest, toWebQueryParams(options));
     return promise;
 }
 
 ScriptPromise Cache::addAllImpl(ScriptState* scriptState, const HeapVector<Member<Request>>& requests, ExceptionState& exceptionState)
 {
     if (requests.isEmpty())
@@ skipping 14 matching lines @@
     }
 
     return ScriptPromise::all(scriptState, promises).then(FetchResolvedForAdd::create(scriptState, this, requests));
 }
 
 ScriptPromise Cache::deleteImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
     batchOperations[0].operationType = WebServiceWorkerCache::OperationTypeDelete;
     request->populateWebServiceWorkerRequest(batchOperations[0].request);
-    checkCacheQueryOptions(options, scriptState->executionContext());
+    checkCacheQueryOptions(options, scriptState->getExecutionContext());
     batchOperations[0].matchParams = toWebQueryParams(options);
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchBatch(new CacheDeleteCallback(resolver), batchOperations);
     return promise;
 }
 
 ScriptPromise Cache::putImpl(ScriptState* scriptState, const HeapVector<Member<Request>>& requests, const HeapVector<Member<Response>>& responses)
 {
@@ skipping 21 matching lines @@
         if (responses[i]->isBodyLocked() || responses[i]->bodyUsed()) {
             barrierCallback->onError("Response body is already used");
             return promise;
         }
 
         BodyStreamBuffer* buffer = responses[i]->internalBodyBuffer();
         if (buffer) {
             // If the response has body, read the all data and create
             // the blob handle and dispatch the put batch asynchronously.
             FetchDataLoader* loader = FetchDataLoader::createLoaderAsBlobHandle(responses[i]->internalMIMEType());
-            buffer->startLoading(scriptState->executionContext(), loader, new BlobHandleCallbackForPut(i, barrierCallback, requests[i], responses[i]));
+            buffer->startLoading(scriptState->getExecutionContext(), loader, new BlobHandleCallbackForPut(i, barrierCallback, requests[i], responses[i]));
             continue;
         }
 
         WebServiceWorkerCache::BatchOperation batchOperation;
         batchOperation.operationType = WebServiceWorkerCache::OperationTypePut;
         requests[i]->populateWebServiceWorkerRequest(batchOperation.request);
         responses[i]->populateWebServiceWorkerResponse(batchOperation.response);
         barrierCallback->onSuccess(i, batchOperation);
     }
 
     return promise;
 }
 
 ScriptPromise Cache::keysImpl(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, WebServiceWorkerCache::QueryParams());
     return promise;
 }
 
 ScriptPromise Cache::keysImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
-    checkCacheQueryOptions(options, scriptState->executionContext());
+    checkCacheQueryOptions(options, scriptState->getExecutionContext());
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, toWebQueryParams(options));
     return promise;
 }
 
 WebServiceWorkerCache* Cache::webCache() const
 {
     return m_webCache.get();
 }
 
 } // namespace blink