Replace usage of GURL(origin.Serialize()) with origin.GetURL()

content/browser/indexed_db/indexed_db_context_impl.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 "content/browser/indexed_db/indexed_db_context_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 131 matching lines @@
   std::set<Origin>* set = GetOriginSet();
   return set->find(origin) != set->end();
 }
 
 std::vector<IndexedDBInfo> IndexedDBContextImpl::GetAllOriginsInfo() {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   std::vector<Origin> origins = GetAllOrigins();
   std::vector<IndexedDBInfo> result;
   for (const auto& origin : origins) {
     size_t connection_count = GetConnectionCount(origin);
-    result.push_back(
-        IndexedDBInfo(GURL(origin.Serialize()), GetOriginDiskUsage(origin),
-                      GetOriginLastModified(origin), connection_count));
+    result.push_back(IndexedDBInfo(origin.GetURL(), GetOriginDiskUsage(origin),
+                                   GetOriginLastModified(origin),
+                                   connection_count));
   }
   return result;
 }
 
 static bool HostNameComparator(const Origin& i, const Origin& j) {
   return i.host() < j.host();
 }
 
 base::ListValue* IndexedDBContextImpl::GetAllOriginsDetails() {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
@@ skipping 267 matching lines @@
 void IndexedDBContextImpl::SetTaskRunnerForTesting(
     base::SequencedTaskRunner* task_runner) {
   DCHECK(!task_runner_.get());
   task_runner_ = task_runner;
 }
 
 void IndexedDBContextImpl::ConnectionOpened(const Origin& origin,
                                             IndexedDBConnection* connection) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   quota_manager_proxy()->NotifyStorageAccessed(
-      storage::QuotaClient::kIndexedDatabase, GURL(origin.Serialize()),
+      storage::QuotaClient::kIndexedDatabase, origin.GetURL(),
       storage::kStorageTypeTemporary);
   if (AddToOriginSet(origin)) {
     // A newly created db, notify the quota system.
     QueryDiskAndUpdateQuotaUsage(origin);
   } else {
     EnsureDiskUsageCacheInitialized(origin);
   }
 }
 
 void IndexedDBContextImpl::ConnectionClosed(const Origin& origin,
                                             IndexedDBConnection* connection) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   quota_manager_proxy()->NotifyStorageAccessed(
-      storage::QuotaClient::kIndexedDatabase, GURL(origin.Serialize()),
+      storage::QuotaClient::kIndexedDatabase, origin.GetURL(),
       storage::kStorageTypeTemporary);
   if (factory_.get() && factory_->GetConnectionCount(origin) == 0)
     QueryDiskAndUpdateQuotaUsage(origin);
 }
 
 void IndexedDBContextImpl::TransactionComplete(const Origin& origin) {
   DCHECK(!factory_.get() || factory_->GetConnectionCount(origin) > 0);
   QueryDiskAndUpdateQuotaUsage(origin);
 }
 
@@ skipping 25 matching lines @@
 
   TaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(
           &ClearSessionOnlyOrigins, data_path_, special_storage_policy_));
 }
 
 // static
 base::FilePath IndexedDBContextImpl::GetBlobStoreFileName(
     const Origin& origin) {
-  std::string origin_id =
-      storage::GetIdentifierFromOrigin(GURL(origin.Serialize()));
+  std::string origin_id = storage::GetIdentifierFromOrigin(origin.GetURL());
   return base::FilePath()
       .AppendASCII(origin_id)
       .AddExtension(kIndexedDBExtension)
       .AddExtension(kBlobExtension);
 }
 
 // static
 base::FilePath IndexedDBContextImpl::GetLevelDBFileName(const Origin& origin) {
-  std::string origin_id =
-      storage::GetIdentifierFromOrigin(GURL(origin.Serialize()));
+  std::string origin_id = storage::GetIdentifierFromOrigin(origin.GetURL());
   return base::FilePath()
       .AppendASCII(origin_id)
       .AddExtension(kIndexedDBExtension)
       .AddExtension(kLevelDBExtension);
 }
 
 base::FilePath IndexedDBContextImpl::GetBlobStorePath(
     const Origin& origin) const {
   DCHECK(!data_path_.empty());
   return data_path_.Append(GetBlobStoreFileName(origin));
@@ skipping 20 matching lines @@
     origin_size_map_[origin] = ReadUsageFromDisk(origin);
 }
 
 void IndexedDBContextImpl::QueryDiskAndUpdateQuotaUsage(const Origin& origin) {
   int64_t former_disk_usage = origin_size_map_[origin];
   int64_t current_disk_usage = ReadUsageFromDisk(origin);
   int64_t difference = current_disk_usage - former_disk_usage;
   if (difference) {
     origin_size_map_[origin] = current_disk_usage;
     quota_manager_proxy()->NotifyStorageModified(
-        storage::QuotaClient::kIndexedDatabase, GURL(origin.Serialize()),
+        storage::QuotaClient::kIndexedDatabase, origin.GetURL(),
         storage::kStorageTypeTemporary, difference);
   }
 }
 
 std::set<Origin>* IndexedDBContextImpl::GetOriginSet() {
   if (!origin_set_) {
     std::vector<Origin> origins;
     GetAllOriginsAndPaths(data_path_, &origins, NULL);
     origin_set_ =
         base::MakeUnique<std::set<Origin>>(origins.begin(), origins.end());
   }
   return origin_set_.get();
 }
 
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
 }
 
 base::SequencedTaskRunner* IndexedDBContextImpl::TaskRunner() const {
   return task_runner_.get();
 }
 
 }  // namespace content