//content: Change ScopedTempDir::path() to GetPath()

content/browser/dom_storage/dom_storage_context_impl_unittest.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 "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 28 matching lines @@
   const base::string16 kKey;
   const base::string16 kValue;
   const bool kDontIncludeFileInfo;
   const bool kDoIncludeFileInfo;
 
   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     storage_policy_ = new MockSpecialStoragePolicy;
     task_runner_ =
         new MockDOMStorageTaskRunner(base::ThreadTaskRunnerHandle::Get().get());
-    context_ = new DOMStorageContextImpl(temp_dir_.path(),
-                                         base::FilePath(),
-                                         storage_policy_.get(),
-                                         task_runner_.get());
+    context_ =
+        new DOMStorageContextImpl(temp_dir_.GetPath(), base::FilePath(),
+                                  storage_policy_.get(), task_runner_.get());
   }
 
   void TearDown() override {
     if (context_)
       context_->Shutdown();
     base::RunLoop().RunUntilIdle();
   }
 
   void VerifySingleOriginRemains(const GURL& origin) {
     // Use a new instance to examine the contexts of temp_dir_.
-    scoped_refptr<DOMStorageContextImpl> context =
-        new DOMStorageContextImpl(temp_dir_.path(), base::FilePath(),
-                                  NULL, NULL);
+    scoped_refptr<DOMStorageContextImpl> context = new DOMStorageContextImpl(
+        temp_dir_.GetPath(), base::FilePath(), NULL, NULL);
     std::vector<LocalStorageUsageInfo> infos;
     context->GetLocalStorageUsage(&infos, kDontIncludeFileInfo);
     ASSERT_EQ(1u, infos.size());
     EXPECT_EQ(origin, infos[0].origin);
     context->Shutdown();
   }
 
   int session_id_offset() { return context_->session_id_offset_; }
 
  protected:
   base::MessageLoop message_loop_;
   base::ScopedTempDir temp_dir_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
   scoped_refptr<MockDOMStorageTaskRunner> task_runner_;
   scoped_refptr<DOMStorageContextImpl> context_;
   DISALLOW_COPY_AND_ASSIGN(DOMStorageContextImplTest);
 };
 
 TEST_F(DOMStorageContextImplTest, Basics) {
   // This test doesn't do much, checks that the constructor
   // initializes members properly and that invoking methods
   // on a newly created object w/o any data on disk do no harm.
-  EXPECT_EQ(temp_dir_.path(), context_->localstorage_directory());
+  EXPECT_EQ(temp_dir_.GetPath(), context_->localstorage_directory());
   EXPECT_EQ(base::FilePath(), context_->sessionstorage_directory());
   EXPECT_EQ(storage_policy_.get(), context_->special_storage_policy_.get());
   context_->DeleteLocalStorage(GURL("http://chromium.org/"));
   const int kFirstSessionStorageNamespaceId = 1 + session_id_offset();
   EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId));
   EXPECT_FALSE(context_->GetStorageNamespace(kFirstSessionStorageNamespaceId));
   EXPECT_EQ(kFirstSessionStorageNamespaceId, context_->AllocateSessionId());
   std::vector<LocalStorageUsageInfo> infos;
   context_->GetLocalStorageUsage(&infos, kDontIncludeFileInfo);
   EXPECT_TRUE(infos.empty());
@@ skipping 12 matching lines @@
   // to ensure data is written to disk.
   base::NullableString16 old_value;
   EXPECT_TRUE(context_->GetStorageNamespace(kLocalStorageNamespaceId)->
       OpenStorageArea(kOrigin)->SetItem(kKey, kValue, &old_value));
   context_->Shutdown();
   context_ = NULL;
   base::RunLoop().RunUntilIdle();
 
   // Create a new context that points to the same directory, see that
   // it knows about the origin that we stored data for.
-  context_ = new DOMStorageContextImpl(temp_dir_.path(), base::FilePath(),
+  context_ = new DOMStorageContextImpl(temp_dir_.GetPath(), base::FilePath(),
                                        NULL, NULL);
   context_->GetLocalStorageUsage(&infos, kDontIncludeFileInfo);
   EXPECT_EQ(1u, infos.size());
   EXPECT_EQ(kOrigin, infos[0].origin);
   EXPECT_EQ(0u, infos[0].data_size);
   EXPECT_EQ(base::Time(), infos[0].last_modified);
   infos.clear();
   context_->GetLocalStorageUsage(&infos, kDoIncludeFileInfo);
   EXPECT_EQ(1u, infos.size());
   EXPECT_EQ(kOrigin, infos[0].origin);
@@ skipping 63 matching lines @@
   EXPECT_EQ(kClonedPersistentId,
             cloned_dom_namespace->persistent_namespace_id());
   // Verify that the areas inherit the persistent ID.
   DOMStorageArea* cloned_area = cloned_dom_namespace->OpenStorageArea(kOrigin);
   EXPECT_EQ(kClonedPersistentId, cloned_area->persistent_namespace_id_);
 }
 
 TEST_F(DOMStorageContextImplTest, DeleteSessionStorage) {
   // Create a DOMStorageContextImpl which will save sessionStorage on disk.
   context_->Shutdown();
-  context_ = new DOMStorageContextImpl(temp_dir_.path(),
-                                       temp_dir_.path(),
-                                       storage_policy_.get(),
-                                       task_runner_.get());
+  context_ =
+      new DOMStorageContextImpl(temp_dir_.GetPath(), temp_dir_.GetPath(),
+                                storage_policy_.get(), task_runner_.get());
   context_->SetSaveSessionStorageOnDisk();
-  ASSERT_EQ(temp_dir_.path(), context_->sessionstorage_directory());
+  ASSERT_EQ(temp_dir_.GetPath(), context_->sessionstorage_directory());
 
   // Write data.
   const int kSessionStorageNamespaceId = 1 + session_id_offset();
   const std::string kPersistentId = "persistent";
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   DOMStorageNamespace* dom_namespace =
       context_->GetStorageNamespace(kSessionStorageNamespaceId);
   DOMStorageArea* area = dom_namespace->OpenStorageArea(kOrigin);
   const base::string16 kKey(ASCIIToUTF16("foo"));
   const base::string16 kValue(ASCIIToUTF16("bar"));
   base::NullableString16 old_nullable_value;
   area->SetItem(kKey, kValue, &old_nullable_value);
   dom_namespace->CloseStorageArea(area);
 
   // Destroy and recreate the DOMStorageContextImpl.
   context_->Shutdown();
   context_ = NULL;
   base::RunLoop().RunUntilIdle();
-  context_ = new DOMStorageContextImpl(
-      temp_dir_.path(), temp_dir_.path(),
-      storage_policy_.get(), task_runner_.get());
+  context_ =
+      new DOMStorageContextImpl(temp_dir_.GetPath(), temp_dir_.GetPath(),
+                                storage_policy_.get(), task_runner_.get());
   context_->SetSaveSessionStorageOnDisk();
 
   // Read the data back.
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   dom_namespace = context_->GetStorageNamespace(kSessionStorageNamespaceId);
   area = dom_namespace->OpenStorageArea(kOrigin);
   base::NullableString16 read_value;
   read_value = area->GetItem(kKey);
   EXPECT_EQ(kValue, read_value.string());
   dom_namespace->CloseStorageArea(area);
 
   SessionStorageUsageInfo info;
   info.origin = kOrigin;
   info.persistent_namespace_id = kPersistentId;
   context_->DeleteSessionStorage(info);
 
   // Destroy and recreate again.
   context_->Shutdown();
   context_ = NULL;
   base::RunLoop().RunUntilIdle();
-  context_ = new DOMStorageContextImpl(
-      temp_dir_.path(), temp_dir_.path(),
-      storage_policy_.get(), task_runner_.get());
+  context_ =
+      new DOMStorageContextImpl(temp_dir_.GetPath(), temp_dir_.GetPath(),
+                                storage_policy_.get(), task_runner_.get());
   context_->SetSaveSessionStorageOnDisk();
 
   // Now there should be no data.
   context_->CreateSessionNamespace(kSessionStorageNamespaceId,
                                    kPersistentId);
   dom_namespace = context_->GetStorageNamespace(kSessionStorageNamespaceId);
   area = dom_namespace->OpenStorageArea(kOrigin);
   read_value = area->GetItem(kKey);
   EXPECT_TRUE(read_value.is_null());
   dom_namespace->CloseStorageArea(area);
@@ skipping 27 matching lines @@
   area2->CommitChanges(area2->commit_batch_.get());
   area2->commit_batch_ = nullptr;
 
   // PURGE_AGGRESSIVE clears the cache in the open area.
   EXPECT_NE(0u, dom_namespace->GetUsageStatistics().total_cache_size);
   context_->PurgeMemory(DOMStorageContextImpl::PURGE_AGGRESSIVE);
   EXPECT_EQ(0u, dom_namespace->GetUsageStatistics().total_cache_size);
 }
 
 }  // namespace content