//[chrome/browser/]net: Change ScopedTempDir::path() to GetPath()

net/extras/sqlite/sqlite_persistent_cookie_store_unittest.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 "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 126 matching lines @@
     // Create a new pool for the few tests that create multiple stores. In other
     // cases this is wasted but harmless.
     pool_owner_.reset(new base::SequencedWorkerPoolOwner(3, "Background Pool"));
   }
 
   void Create(bool crypt_cookies, bool restore_old_session_cookies) {
     if (crypt_cookies)
       cookie_crypto_delegate_.reset(new CookieCryptor());
 
     store_ = new SQLitePersistentCookieStore(
-        temp_dir_.path().Append(kCookieFilename), client_task_runner(),
+        temp_dir_.GetPath().Append(kCookieFilename), client_task_runner(),
         background_task_runner(), restore_old_session_cookies,
         cookie_crypto_delegate_.get());
   }
 
   void CreateAndLoad(bool crypt_cookies,
                      bool restore_old_session_cookies,
                      CanonicalCookieVector* cookies) {
     Create(crypt_cookies, restore_old_session_cookies);
     Load(cookies);
   }
@@ skipping 27 matching lines @@
                                const std::string& path,
                                const base::Time& creation,
                                const base::Time& expiration) {
     store_->AddCookie(*CanonicalCookie::Create(
         url, name, value, domain, path, creation, expiration, false, false,
         CookieSameSite::DEFAULT_MODE, false, COOKIE_PRIORITY_DEFAULT));
   }
 
   std::string ReadRawDBContents() {
     std::string contents;
-    if (!base::ReadFileToString(temp_dir_.path().Append(kCookieFilename),
+    if (!base::ReadFileToString(temp_dir_.GetPath().Append(kCookieFilename),
                                 &contents))
       return std::string();
     return contents;
   }
 
   void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); }
 
   void TearDown() override {
     DestroyStore();
   }
@@ skipping 21 matching lines @@
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("A", cookies[0]->Name().c_str());
   ASSERT_STREQ("B", cookies[0]->Value().c_str());
   DestroyStore();
   base::STLDeleteElements(&cookies);
 
   // Now corrupt the meta table.
   {
     sql::Connection db;
-    ASSERT_TRUE(db.Open(temp_dir_.path().Append(kCookieFilename)));
+    ASSERT_TRUE(db.Open(temp_dir_.GetPath().Append(kCookieFilename)));
     sql::MetaTable meta_table_;
     meta_table_.Init(&db, 1, 1);
     ASSERT_TRUE(db.Execute("DELETE FROM meta"));
     db.Close();
   }
 
   // Upon loading, the database should be reset to a good, blank state.
   CreateAndLoad(false, false, &cookies);
   ASSERT_EQ(0U, cookies.size());
 
@@ skipping 63 matching lines @@
   AddCookieWithExpiration(GURL("http://b4.com"), "A", "B", std::string(), "/",
                           t, base::Time());
   t += base::TimeDelta::FromInternalValue(10);
   AddCookieWithExpiration(GURL("http://b5.com"), "A", "B", std::string(), "/",
                           t, base::Time());
   DestroyStore();
 
   // Load the store a second time. Before the store finishes loading, add a
   // transient cookie and flush it to disk.
   store_ = new SQLitePersistentCookieStore(
-      temp_dir_.path().Append(kCookieFilename), client_task_runner(),
+      temp_dir_.GetPath().Append(kCookieFilename), client_task_runner(),
       background_task_runner(), false, nullptr);
 
   // Posting a blocking task to db_thread_ makes sure that the DB thread waits
   // until both Load and Flush have been posted to its task queue.
   background_task_runner()->PostTask(
       FROM_HERE, base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
                             base::Unretained(this)));
   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                           base::Unretained(this)));
   t += base::TimeDelta::FromInternalValue(10);
@@ skipping 14 matching lines @@
   db_thread_event_.Signal();
   event.Wait();
   loaded_event_.Wait();
   base::STLDeleteElements(&cookies_);
   DestroyStore();
 
   // Load the store a third time, this time restoring session cookies. The
   // store should contain exactly 4 cookies: the 3 persistent, and "c.com",
   // which was added during the second cookie store load.
   store_ = new SQLitePersistentCookieStore(
-      temp_dir_.path().Append(kCookieFilename), client_task_runner(),
+      temp_dir_.GetPath().Append(kCookieFilename), client_task_runner(),
       background_task_runner(), true, nullptr);
   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                           base::Unretained(this)));
   loaded_event_.Wait();
   ASSERT_EQ(4u, cookies_.size());
   base::STLDeleteElements(&cookies_);
 }
 
 // Test that priority load of cookies for a specfic domain key could be
 // completed before the entire store is loaded
 TEST_F(SQLitePersistentCookieStoreTest, TestLoadCookiesForKey) {
   InitializeStore(false, false);
   base::Time t = base::Time::Now();
   AddCookie(GURL("http://foo.bar"), "A", "B", std::string(), "/", t);
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie(GURL("http://www.aaa.com"), "A", "B", std::string(), "/", t);
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie(GURL("http://travel.aaa.com"), "A", "B", std::string(), "/", t);
   t += base::TimeDelta::FromInternalValue(10);
   AddCookie(GURL("http://www.bbb.com"), "A", "B", std::string(), "/", t);
   DestroyStore();
 
   store_ = new SQLitePersistentCookieStore(
-      temp_dir_.path().Append(kCookieFilename), client_task_runner(),
+      temp_dir_.GetPath().Append(kCookieFilename), client_task_runner(),
       background_task_runner(), false, nullptr);
 
   // Posting a blocking task to db_thread_ makes sure that the DB thread waits
   // until both Load and LoadCookiesForKey have been posted to its task queue.
   background_task_runner()->PostTask(
       FROM_HERE, base::Bind(&SQLitePersistentCookieStoreTest::WaitOnDBEvent,
                             base::Unretained(this)));
   store_->Load(base::Bind(&SQLitePersistentCookieStoreTest::OnLoaded,
                           base::Unretained(this)));
   store_->LoadCookiesForKey(
@@ skipping 34 matching lines @@
   ASSERT_EQ(cookies_loaded.find("foo.bar") != cookies_loaded.end(), true);
   ASSERT_EQ(cookies_loaded.find("www.bbb.com") != cookies_loaded.end(), true);
   base::STLDeleteElements(&cookies_);
 }
 
 // Test that we can force the database to be written by calling Flush().
 TEST_F(SQLitePersistentCookieStoreTest, TestFlush) {
   InitializeStore(false, false);
   // File timestamps don't work well on all platforms, so we'll determine
   // whether the DB file has been modified by checking its size.
-  base::FilePath path = temp_dir_.path().Append(kCookieFilename);
+  base::FilePath path = temp_dir_.GetPath().Append(kCookieFilename);
   base::File::Info info;
   ASSERT_TRUE(base::GetFileInfo(path, &info));
   int64_t base_size = info.size;
 
   // Write some large cookies, so the DB will have to expand by several KB.
   for (char c = 'a'; c < 'z'; ++c) {
     // Each cookie needs a unique timestamp for creation_utc (see DB schema).
     base::Time t = base::Time::Now() + base::TimeDelta::FromMicroseconds(c);
     std::string name(1, c);
     std::string value(1000, c);
@@ skipping 273 matching lines @@
   }
   EXPECT_EQ("encrypted_value123XYZ", cookie_name->Value());
   EXPECT_EQ("something456ABC", cookie_other->Value());
   DestroyStore();
   base::STLDeleteElements(&cookies_);
 
   // Examine the real record to make sure plaintext version doesn't exist.
   sql::Connection db;
   sql::Statement smt;
   int resultcount = 0;
-  ASSERT_TRUE(db.Open(temp_dir_.path().Append(kCookieFilename)));
+  ASSERT_TRUE(db.Open(temp_dir_.GetPath().Append(kCookieFilename)));
   smt.Assign(db.GetCachedStatement(SQL_FROM_HERE,
                                    "SELECT * "
                                    "FROM cookies "
                                    "WHERE host_key = 'foo.bar'"));
   while (smt.Step()) {
     resultcount++;
     for (int i = 0; i < smt.ColumnCount(); i++) {
       EXPECT_EQ(smt.ColumnString(i).find("value"), std::string::npos);
       EXPECT_EQ(smt.ColumnString(i).find("something"), std::string::npos);
     }
@@ skipping 85 matching lines @@
   EXPECT_TRUE(was_called_with_no_cookies);
 
   // Same with trying to load a specific cookie.
   was_called_with_no_cookies = false;
   store_->LoadCookiesForKey("foo.bar", base::Bind(WasCalledWithNoCookies,
                                                   &was_called_with_no_cookies));
   EXPECT_TRUE(was_called_with_no_cookies);
 }
 
 }  // namespace net