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::IO, FROM_HERE,
+                          base::Bind(callback, data, success, not_found));

[nhiroki, 2015/01/26 11:52:30]

You might want to directly call the callback because we're already on the IO
thread:

  callback.Run(data, success, not_found);

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

Done (good point!).

+}
+
+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::IO, FROM_HERE,
+                          base::Bind(callback, success));

[nhiroki, 2015/01/26 11:52:30]

ditto.

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

Done.

+}
+
+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