IndexedDB: Use url::Origin rather than GURL for representing origins

content/browser/indexed_db/indexed_db_browsertest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 26 matching lines @@
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/database/database_util.h"
 #include "storage/browser/quota/quota_manager.h"
+#include "url/gurl.h"
+#include "url/origin.h"
 
 using base::ASCIIToUTF16;
 using storage::QuotaManager;
 using storage::DatabaseUtil;
+using url::Origin;
 
 namespace content {
 
 // This browser test is aimed towards exercising the IndexedDB bindings and
 // the actual implementation that lives in the browser side.
 class IndexedDBBrowserTest : public ContentBrowserTest,
                              public ::testing::WithParamInterface<const char*> {
  public:
   IndexedDBBrowserTest() : disk_usage_(-1) {}
 
@@ skipping 93 matching lines @@
     EXPECT_TRUE(helper->Run());
     // Wait for DidGetDiskUsage to be called.
     base::MessageLoop::current()->RunUntilIdle();
     return disk_usage_;
   }
 
   virtual int RequestBlobFileCount() {
     PostTaskAndReplyWithResult(
         GetContext()->TaskRunner(), FROM_HERE,
         base::Bind(&IndexedDBContextImpl::GetOriginBlobFileCount, GetContext(),
-                   GURL("file:///")),
+                   Origin(GURL("file:///"))),
         base::Bind(&IndexedDBBrowserTest::DidGetBlobFileCount, this));
     scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
         BrowserMainLoop::GetInstance()->indexed_db_thread()->task_runner()));
     EXPECT_TRUE(helper->Run());
     // Wait for DidGetBlobFileCount to be called.
     base::MessageLoop::current()->RunUntilIdle();
     return blob_file_count_;
   }
 
  private:
@@ skipping 256 matching lines @@
   SimpleTest(GetTestUrl("indexeddb", "fill_up_5k.html"));
   int64_t size = RequestDiskUsage();
   const int kQuotaKilobytes = 2;
   EXPECT_GT(size, kQuotaKilobytes * 1024);
   SetQuota(kQuotaKilobytes);
   SimpleTest(GetTestUrl("indexeddb", "delete_over_quota.html"));
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, EmptyBlob) {
   // First delete all IDB's for the test origin
+  // TODO(jsbell): Remove static_cast<> when overloads are eliminated.
   GetContext()->TaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&IndexedDBContextImpl::DeleteForOrigin,
-                            GetContext(), GURL("file:///")));
+      FROM_HERE,
+      base::Bind(static_cast<void (IndexedDBContextImpl::*)(const GURL&)>(
+                     &IndexedDBContextImpl::DeleteForOrigin),
+                 GetContext(), GURL("file:///")));
   EXPECT_EQ(0, RequestBlobFileCount());  // Start with no blob files.
   const GURL test_url = GetTestUrl("indexeddb", "empty_blob.html");
   // For some reason Android's futimes fails (EPERM) in this test. Do not assert
   // file times on Android, but do so on other platforms. crbug.com/467247
   // TODO(cmumford): Figure out why this is the case and fix if possible.
 #if defined(OS_ANDROID)
   SimpleTest(GURL(test_url.spec() + "#ignoreTimes"));
 #else
   SimpleTest(GURL(test_url.spec()));
 #endif
@@ skipping 28 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, BlobsCountAgainstQuota) {
   SimpleTest(GetTestUrl("indexeddb", "blobs_use_quota.html"));
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, DeleteForOriginDeletesBlobs) {
   SimpleTest(GetTestUrl("indexeddb", "write_20mb_blob.html"));
   int64_t size = RequestDiskUsage();
   // This assertion assumes that we do not compress blobs.
   EXPECT_GT(size, 20 << 20 /* 20 MB */);
+  // TODO(jsbell): Remove static_cast<> when overloads are eliminated.
   GetContext()->TaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&IndexedDBContextImpl::DeleteForOrigin,
-                            GetContext(), GURL("file:///")));
+      FROM_HERE,
+      base::Bind(static_cast<void (IndexedDBContextImpl::*)(const GURL&)>(
+                     &IndexedDBContextImpl::DeleteForOrigin),
+                 GetContext(), GURL("file:///")));
   scoped_refptr<base::ThreadTestHelper> helper(new base::ThreadTestHelper(
       BrowserMainLoop::GetInstance()->indexed_db_thread()->task_runner()));
   ASSERT_TRUE(helper->Run());
   EXPECT_EQ(0, RequestDiskUsage());
 }
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, DiskFullOnCommit) {
   // Ignore several preceding transactions:
   // * The test calls deleteDatabase() which opens the backing store:
   //   #1: IndexedDBBackingStore::OpenBackingStore
@@ skipping 11 matching lines @@
   const int call_num = 1;
   FailOperation(FAIL_CLASS_LEVELDB_TRANSACTION, FAIL_METHOD_COMMIT_DISK_FULL,
                 instance_num, call_num);
   SimpleTest(GetTestUrl("indexeddb", "disk_full_on_commit.html"));
 }
 
 namespace {
 
 static void CompactIndexedDBBackingStore(
     scoped_refptr<IndexedDBContextImpl> context,
-    const GURL& origin_url) {
+    const Origin& origin) {
   IndexedDBFactory* factory = context->GetIDBFactory();
 
   std::pair<IndexedDBFactory::OriginDBMapIterator,
-            IndexedDBFactory::OriginDBMapIterator> range =
-      factory->GetOpenDatabasesForOrigin(origin_url);
+            IndexedDBFactory::OriginDBMapIterator>
+      range = factory->GetOpenDatabasesForOrigin(origin);
 
   if (range.first == range.second)  // If no open db's for this origin
     return;
 
   // Compact the first db's backing store since all the db's are in the same
   // backing store.
   IndexedDBDatabase* db = range.first->second;
   IndexedDBBackingStore* backing_store = db->backing_store();
   backing_store->Compact();
 }
 
 static void CorruptIndexedDBDatabase(
     IndexedDBContextImpl* context,
-    const GURL& origin_url,
+    const Origin& origin,
     base::WaitableEvent* signal_when_finished) {
-
-  CompactIndexedDBBackingStore(context, origin_url);
+  CompactIndexedDBBackingStore(context, origin);
 
   int num_files = 0;
   int num_errors = 0;
   const bool recursive = false;
-  for (const base::FilePath& idb_data_path :
-       context->GetStoragePaths(origin_url)) {
+  for (const base::FilePath& idb_data_path : context->GetStoragePaths(origin)) {
     base::FileEnumerator enumerator(
         idb_data_path, recursive, base::FileEnumerator::FILES);
     for (base::FilePath idb_file = enumerator.Next(); !idb_file.empty();
          idb_file = enumerator.Next()) {
       int64_t size(0);
       GetFileSize(idb_file, &size);
 
       if (idb_file.Extension() == FILE_PATH_LITERAL(".ldb")) {
         num_files++;
         base::File file(
@@ skipping 11 matching lines @@
             << " with " << num_errors << " errors";
   }
 
   signal_when_finished->Signal();
 }
 
 const std::string s_corrupt_db_test_prefix = "/corrupt/test/";
 
 static std::unique_ptr<net::test_server::HttpResponse> CorruptDBRequestHandler(
     IndexedDBContextImpl* context,
-    const GURL& origin_url,
+    const Origin& origin,
     const std::string& path,
     IndexedDBBrowserTest* test,
     const net::test_server::HttpRequest& request) {
   std::string request_path;
   if (path.find(s_corrupt_db_test_prefix) != std::string::npos)
     request_path = request.relative_url.substr(s_corrupt_db_test_prefix.size());
   else
     return std::unique_ptr<net::test_server::HttpResponse>();
 
   // Remove the query string if present.
   std::string request_query;
   size_t query_pos = request_path.find('?');
   if (query_pos != std::string::npos) {
     request_query = request_path.substr(query_pos + 1);
     request_path = request_path.substr(0, query_pos);
   }
 
   if (request_path == "corruptdb" && !request_query.empty()) {
     VLOG(0) << "Requested to corrupt IndexedDB: " << request_query;
     base::WaitableEvent signal_when_finished(false, false);
-    context->TaskRunner()->PostTask(FROM_HERE,
-                                    base::Bind(&CorruptIndexedDBDatabase,
-                                               base::ConstRef(context),
-                                               origin_url,
-                                               &signal_when_finished));
+    context->TaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&CorruptIndexedDBDatabase, base::ConstRef(context), origin,
+                   &signal_when_finished));
     signal_when_finished.Wait();
 
     std::unique_ptr<net::test_server::BasicHttpResponse> http_response(
         new net::test_server::BasicHttpResponse);
     http_response->set_code(net::HTTP_OK);
     return std::move(http_response);
   } else if (request_path == "fail" && !request_query.empty()) {
     FailClass failure_class = FAIL_CLASS_NOTHING;
     FailMethod failure_method = FAIL_METHOD_NOTHING;
     int instance_num = 1;
@@ skipping 72 matching lines @@
     return std::unique_ptr<net::test_server::HttpResponse>();
   http_response->set_content(file_contents);
   return std::move(http_response);
 }
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_P(IndexedDBBrowserTest, OperationOnCorruptedOpenDatabase) {
   ASSERT_TRUE(embedded_test_server()->Started() ||
               embedded_test_server()->Start());
-  const GURL& origin_url = embedded_test_server()->base_url();
+  const Origin origin(embedded_test_server()->base_url());
   embedded_test_server()->RegisterRequestHandler(
-      base::Bind(&CorruptDBRequestHandler,
-                 base::Unretained(GetContext()),
-                 origin_url,
-                 s_corrupt_db_test_prefix,
-                 this));
+      base::Bind(&CorruptDBRequestHandler, base::Unretained(GetContext()),
+                 origin, s_corrupt_db_test_prefix, this));
 
   std::string test_file = s_corrupt_db_test_prefix +
                           "corrupted_open_db_detection.html#" + GetParam();
   SimpleTest(embedded_test_server()->GetURL(test_file));
 
   test_file = s_corrupt_db_test_prefix + "corrupted_open_db_recovery.html";
   SimpleTest(embedded_test_server()->GetURL(test_file));
 }
 
 INSTANTIATE_TEST_CASE_P(IndexedDBBrowserTestInstantiation,
@@ skipping 103 matching lines @@
   shell()->Close();
 
   EXPECT_EQ(expected_title16, title_watcher.WaitAndGetTitle());
 }
 
 // Verify that a "close" event is fired at database connections when
 // the backing store is deleted.
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTest, ForceCloseEventTest) {
   NavigateAndWaitForTitle(shell(), "force_close_event.html", NULL,
                           "connection ready");
-
+  // TODO(jsbell): Remove static_cast<> when overloads are eliminated.
   GetContext()->TaskRunner()->PostTask(
       FROM_HERE,
-      base::Bind(&IndexedDBContextImpl::DeleteForOrigin,
-                 GetContext(),
-                 GURL("file:///")));
+      base::Bind(static_cast<void (IndexedDBContextImpl::*)(const GURL&)>(
+                     &IndexedDBContextImpl::DeleteForOrigin),
+                 GetContext(), GURL("file:///")));
 
   base::string16 expected_title16(ASCIIToUTF16("connection closed"));
   TitleWatcher title_watcher(shell()->web_contents(), expected_title16);
   title_watcher.AlsoWaitForTitle(ASCIIToUTF16("connection closed with error"));
   EXPECT_EQ(expected_title16, title_watcher.WaitAndGetTitle());
 }
 
 class IndexedDBBrowserTestSingleProcess : public IndexedDBBrowserTest {
  public:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(switches::kSingleProcess);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(IndexedDBBrowserTestSingleProcess,
                        RenderThreadShutdownTest) {
   SimpleTest(GetTestUrl("indexeddb", "shutdown_with_requests.html"));
 }
 
 }  // namespace content