Service Worker: Expose Get/Store/ClearUserData to content layer.

content/browser/service_worker/service_worker_context_wrapper.cc

 // Copyright 2013 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 "content/browser/service_worker/service_worker_context_wrapper.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_quota_client.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
 #include "content/browser/storage_partition_impl.h"
+#include "content/common/service_worker/service_worker_status_code.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/service_worker_context.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
@@ skipping 176 matching lines @@
         FROM_HERE,
         base::Bind(continuation, false));
     return;
   }
 
   context()->UnregisterServiceWorker(
       pattern,
       base::Bind(&FinishUnregistrationOnIO, continuation));
 }
 
+static void CallGetUserDataCallback(
+    const ServiceWorkerContext::GetUserDataCallback& callback,
+    const std::string& data,
+    ServiceWorkerStatusCode service_worker_status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  bool success = service_worker_status == SERVICE_WORKER_OK;
+  bool not_found = service_worker_status == SERVICE_WORKER_ERROR_NOT_FOUND;
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, data, success, not_found));

[nhiroki, 2015/01/26 03:25:26]

I'd prefer to run the callback on the IO thread because
{Get,Store,Clear}UserData() is assumed to be called on the IO thread. IMO,
function and its callback should be called on the same thread.

(Although other functions are doing the similar thing (running the callback on
the UI thread), probably they need to be fixed in a separate CL)

[johnme, 2015/01/26 11:02:58]

Done (oops, that was actually my intention, but I had a typo).

+}
+
+static void CallResultCallback(
+    const ServiceWorkerContext::ResultCallback& callback,
+    ServiceWorkerStatusCode service_worker_status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  bool success = service_worker_status == SERVICE_WORKER_OK;
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, success));
+}
+
+void ServiceWorkerContextWrapper::GetUserData(
+    int64 registration_id, const std::string& key,
+    const GetUserDataCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  context()->storage()->GetUserData(registration_id, key,
+                                    base::Bind(&CallGetUserDataCallback,
+                                               callback));
+}
+
+void ServiceWorkerContextWrapper::StoreUserData(
+    int64 registration_id, const GURL& origin, const std::string& key,
+    const std::string& data, const ResultCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  context()->storage()->StoreUserData(registration_id, origin, key, data,
+                                      base::Bind(&CallResultCallback,
+                                                 callback));
+}
+
+void ServiceWorkerContextWrapper::ClearUserData(
+    int64 registration_id, const std::string& key,
+    const ResultCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  context()->storage()->ClearUserData(registration_id, key,
+                                      base::Bind(&CallResultCallback,
+                                                 callback));
+}
+
 static void DidFindRegistrationForDocument(
     const net::CompletionCallback& callback,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   int rv = registration ? net::OK : net::ERR_CACHE_MISS;
   // Use RunSoon here because FindRegistrationForDocument can complete
   // immediately but CanHandleMainResourceOffline must be async.
   RunSoon(base::Bind(callback, rv));
 }
 
@@ skipping 147 matching lines @@
     context_core_.reset();
     return;
   }
   context_core_.reset(new ServiceWorkerContextCore(context_core_.get(), this));
   DVLOG(1) << "Restarted ServiceWorkerContextCore successfully.";
 
   observer_list_->Notify(&ServiceWorkerContextObserver::OnStorageWiped);
 }
 
 }  // namespace content