[Storage] Blob Storage Refactoring pt 1

content/browser/service_worker/service_worker_browsertest.cc

 // 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 30 matching lines @@
 #include "storage/common/blob/blob_data.h"
 
 namespace content {
 
 namespace {
 
 struct FetchResult {
   ServiceWorkerStatusCode status;
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+  scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle;
 };
 
 void RunAndQuit(const base::Closure& closure,
                 const base::Closure& quit,
                 base::MessageLoopProxy* original_message_loop) {
   closure.Run();
   original_message_loop->PostTask(FROM_HERE, quit);
 }
 
 void RunOnIOThread(const base::Closure& closure) {
@@ skipping 53 matching lines @@
     BrowserThread::ID run_quit_thread,
     const base::Closure& quit,
     ChromeBlobStorageContext* blob_context,
     FetchResult* result) {
   return base::Bind(&ReceiveFetchResult, run_quit_thread, quit,
                     make_scoped_refptr<ChromeBlobStorageContext>(blob_context),
                     result);
 }
 
 void ReadResponseBody(std::string* body,
-                      storage::BlobDataHandle* blob_data_handle) {
+                      storage::BlobDataSnapshotHandle* blob_data_handle) {
   ASSERT_TRUE(blob_data_handle);
   ASSERT_EQ(1U, blob_data_handle->data()->items().size());
-  *body = std::string(blob_data_handle->data()->items()[0].bytes(),
-                      blob_data_handle->data()->items()[0].length());
+  *body = std::string(blob_data_handle->data()->items()[0]->bytes(),
+                      blob_data_handle->data()->items()[0]->length());
 }
 
 void ExpectResultAndRun(bool expected,
                         const base::Closure& continuation,
                         bool actual) {
   EXPECT_EQ(expected, actual);
   continuation.Run();
 }
 
 class WorkerActivatedObserver
@@ skipping 325 matching lines @@
         FROM_HERE,
         base::Bind(
             &self::ActivateOnIOThread, this, run_loop.QuitClosure(), &status));
     run_loop.Run();
     ASSERT_EQ(expected_status, status);
   }
 
   void FetchOnRegisteredWorker(
       ServiceWorkerFetchEventResult* result,
       ServiceWorkerResponse* response,
-      scoped_ptr<storage::BlobDataHandle>* blob_data_handle) {
+      scoped_ptr<storage::BlobDataSnapshotHandle>* blob_data_handle) {
     blob_context_ = ChromeBlobStorageContext::GetFor(
         shell()->web_contents()->GetBrowserContext());
     bool prepare_result = false;
     FetchResult fetch_result;
     fetch_result.status = SERVICE_WORKER_ERROR_FAILED;
     base::RunLoop fetch_run_loop;
     BrowserThread::PostTask(BrowserThread::IO,
                             FROM_HERE,
                             base::Bind(&self::FetchOnIOThread,
                                        this,
                                        fetch_run_loop.QuitClosure(),
                                        &prepare_result,
                                        &fetch_result));
     fetch_run_loop.Run();
     ASSERT_TRUE(prepare_result);
     *result = fetch_result.result;
     *response = fetch_result.response;
     *blob_data_handle = fetch_result.blob_data_handle.Pass();
     ASSERT_EQ(SERVICE_WORKER_OK, fetch_result.status);
   }
 
-  void FetchTestHelper(const std::string& worker_url,
-                       ServiceWorkerFetchEventResult* result,
-                       ServiceWorkerResponse* response,
-                       scoped_ptr<storage::BlobDataHandle>* blob_data_handle) {
+  void FetchTestHelper(
+      const std::string& worker_url,
+      ServiceWorkerFetchEventResult* result,
+      ServiceWorkerResponse* response,
+      scoped_ptr<storage::BlobDataSnapshotHandle>* blob_data_handle) {
     RunOnIOThread(
         base::Bind(&self::SetUpRegistrationOnIOThread, this, worker_url));
     FetchOnRegisteredWorker(result, response, blob_data_handle);
   }
 
   void SetUpRegistrationOnIOThread(const std::string& worker_url) {
     const GURL pattern = embedded_test_server()->GetURL("/");
     registration_ = new ServiceWorkerRegistration(
         pattern,
         wrapper()->context()->storage()->NewRegistrationId(),
@@ skipping 179 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        InstallWithWaitUntil_Rejected) {
   InstallTestHelper("/service_worker/worker_install_rejected.js",
                     SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, FetchEvent_Response) {
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+  scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle;
   FetchTestHelper("/service_worker/fetch_event.js",
                   &result, &response, &blob_data_handle);
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result);
   EXPECT_EQ(301, response.status_code);
   EXPECT_EQ("Moved Permanently", response.status_text);
   ServiceWorkerHeaderMap expected_headers;
   expected_headers["content-language"] = "fi";
   expected_headers["content-type"] = "text/html; charset=UTF-8";
   EXPECT_EQ(expected_headers, response.headers);
 
@@ skipping 23 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, SyncEventHandled) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   command_line->AppendSwitch(switches::kEnableServiceWorkerSync);
 
   RunOnIOThread(base::Bind(
       &self::SetUpRegistrationOnIOThread, this, "/service_worker/sync.js"));
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+  scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle;
   // Should 404 before sync event.
   FetchOnRegisteredWorker(&result, &response, &blob_data_handle);
   EXPECT_EQ(404, response.status_code);
 
   // Run the sync event.
   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
   base::RunLoop sync_run_loop;
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&self::SyncEventOnIOThread,
@@ skipping 214 matching lines @@
   const base::string16 kOKTitle2(base::ASCIIToUTF16("OK_2"));
   const base::string16 kFailTitle2(base::ASCIIToUTF16("FAIL_2"));
   content::TitleWatcher title_watcher2(shell()->web_contents(), kOKTitle2);
   title_watcher2.AlsoWaitForTitle(kFailTitle2);
 
   NavigateToURL(shell(), embedded_test_server()->GetURL(kConfirmPageUrl));
   EXPECT_EQ(kOKTitle2, title_watcher2.WaitAndGetTitle());
 }
 
 }  // namespace content