chromeos: Stop returning scoped_ptr from GDataCache::GetCacheEntry

chrome/browser/chromeos/gdata/gdata_cache_metadata_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 "chrome/browser/chromeos/gdata/gdata_cache_metadata.h"
 
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 93 matching lines @@
   }
 
   // Create an symlink to |target| at |symlink|.
   void CreateSymbolicLink(const FilePath& target, const FilePath& symlink) {
     ASSERT_TRUE(file_util::CreateSymbolicLink(target, symlink))
         << ": " << target.value() << ": " << symlink.value();
   }
 
  protected:
   // Helper function to insert an item with key |resource_id| into |cache_map|.
-  // |md5|, |sub_dir_type|, |cache_state| are used to create the value
-  // CacheEntry.
+  // |md5| and |cache_state| are used to create the value CacheEntry.
   void InsertIntoMap(GDataCacheMetadataMap::CacheMap* cache_map,
                      const std::string& resource_id,
                      const std::string& md5,
                      int cache_state) {
     cache_map->insert(std::make_pair(
         resource_id, GDataCacheEntry(md5, cache_state)));
   }
 
   ScopedTempDir temp_dir_;
   scoped_ptr<GDataCacheMetadataMap> metadata_;
   std::vector<FilePath> cache_paths_;
   FilePath persistent_directory_;
   FilePath tmp_directory_;
   FilePath pinned_directory_;
   FilePath outgoing_directory_;
 };
 
 // Test all the methods of GDataCacheMetadataMap except for
 // RemoveTemporaryFiles.
 TEST_F(GDataCacheMetadataMapTest, CacheTest) {
   SetUpCacheMetadata();
 
   // Save an initial entry.
   std::string test_resource_id("test_resource_id");
   std::string test_file_md5("test_file_md5");
   GDataCache::CacheSubDirectoryType test_sub_dir_type =
       GDataCache::CACHE_TYPE_PERSISTENT;
-  int test_cache_state = (CACHE_STATE_PRESENT |
-                          CACHE_STATE_PERSISTENT);
+  int test_cache_state = (CACHE_STATE_PRESENT | CACHE_STATE_PERSISTENT);
   metadata_->AddOrUpdateCacheEntry(
       test_resource_id,
       GDataCacheEntry(test_file_md5, test_cache_state));
 
   // Test that the entry can be retrieved.
-  scoped_ptr<GDataCacheEntry> cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, test_file_md5);
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ(test_file_md5, cache_entry->md5());
-  EXPECT_EQ(test_sub_dir_type, GDataCache::GetSubDirectoryType(*cache_entry));
-  EXPECT_EQ(test_cache_state, cache_entry->cache_state());
+  GDataCacheEntry cache_entry;
+  ASSERT_TRUE(metadata_->GetCacheEntry(
+      test_resource_id, test_file_md5, &cache_entry));
+  EXPECT_EQ(test_file_md5, cache_entry.md5());
+  EXPECT_EQ(test_sub_dir_type, GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(test_cache_state, cache_entry.cache_state());
 
   // Empty md5 should also work.
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, std::string()).Pass();
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ(test_file_md5, cache_entry->md5());
+  ASSERT_TRUE(metadata_->GetCacheEntry(
+      test_resource_id, std::string(), &cache_entry));
+  EXPECT_EQ(test_file_md5, cache_entry.md5());
 
   // resource_id doesn't exist.
-  cache_entry = metadata_->GetCacheEntry("not_found_resource_id",
-                                         std::string()).Pass();
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry(
+      "not_found_resource_id", std::string(), &cache_entry));
 
   // md5 doesn't match.
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, "mismatch_md5").Pass();
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry(
+      test_resource_id, "mismatch_md5", &cache_entry));
 
   // Update all attributes.
   test_file_md5 = "test_file_md5_2";
   test_sub_dir_type = GDataCache::CACHE_TYPE_TMP;
   test_cache_state = CACHE_STATE_PINNED;
   metadata_->AddOrUpdateCacheEntry(
       test_resource_id,
       GDataCacheEntry(test_file_md5, test_cache_state));
 
   // Make sure the values took.
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, test_file_md5).Pass();
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ(test_file_md5, cache_entry->md5());
-  EXPECT_EQ(test_sub_dir_type, GDataCache::GetSubDirectoryType(*cache_entry));
-  EXPECT_EQ(test_cache_state, cache_entry->cache_state());
+  ASSERT_TRUE(metadata_->GetCacheEntry(
+      test_resource_id, test_file_md5, &cache_entry));
+  EXPECT_EQ(test_file_md5, cache_entry.md5());
+  EXPECT_EQ(test_sub_dir_type, GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(test_cache_state, cache_entry.cache_state());
 
   // Empty m5 should work.
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, std::string()).Pass();
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ(test_file_md5, cache_entry->md5());
+  ASSERT_TRUE(metadata_->GetCacheEntry(
+      test_resource_id, std::string(), &cache_entry));
+  EXPECT_EQ(test_file_md5, cache_entry.md5());
 
   // Test dirty cache.
   test_file_md5 = "test_file_md5_3";
   test_sub_dir_type = GDataCache::CACHE_TYPE_TMP;
   test_cache_state = CACHE_STATE_DIRTY;
   metadata_->AddOrUpdateCacheEntry(
       test_resource_id,
       GDataCacheEntry(test_file_md5, test_cache_state));
 
   // Make sure the values took.
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, test_file_md5).Pass();
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ(test_file_md5, cache_entry->md5());
-  EXPECT_EQ(test_sub_dir_type, GDataCache::GetSubDirectoryType(*cache_entry));
-  EXPECT_EQ(test_cache_state, cache_entry->cache_state());
+  ASSERT_TRUE(metadata_->GetCacheEntry(
+      test_resource_id, test_file_md5, &cache_entry));
+  EXPECT_EQ(test_file_md5, cache_entry.md5());
+  EXPECT_EQ(test_sub_dir_type, GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(test_cache_state, cache_entry.cache_state());
 
   // Empty md5 should work.
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, std::string()).Pass();
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ(test_file_md5, cache_entry->md5());
+  ASSERT_TRUE(metadata_->GetCacheEntry(
+      test_resource_id, std::string(), &cache_entry));
+  EXPECT_EQ(test_file_md5, cache_entry.md5());
 
   // Mismatched md5 should also work for dirty entries.
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, "mismatch_md5").Pass();
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ(test_file_md5, cache_entry->md5());
+  ASSERT_TRUE(metadata_->GetCacheEntry(
+      test_resource_id, "mismatch_md5", &cache_entry));
+  EXPECT_EQ(test_file_md5, cache_entry.md5());
 
   // Remove the entry.
   metadata_->RemoveCacheEntry(test_resource_id);
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, std::string()).Pass();
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry(
+      test_resource_id, std::string(), &cache_entry));
 
   // Add another one.
   test_resource_id = "test_resource_id_2";
   test_file_md5 = "test_file_md5_4";
   test_sub_dir_type = GDataCache::CACHE_TYPE_TMP;
   test_cache_state = CACHE_STATE_PRESENT;
   metadata_->AddOrUpdateCacheEntry(
       test_resource_id,
       GDataCacheEntry(test_file_md5, test_cache_state));
 
   // Make sure the values took.
-  cache_entry =
-      metadata_->GetCacheEntry(test_resource_id, test_file_md5).Pass();
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ(test_file_md5, cache_entry->md5());
-  EXPECT_EQ(test_sub_dir_type, GDataCache::GetSubDirectoryType(*cache_entry));
-  EXPECT_EQ(test_cache_state, cache_entry->cache_state());
+  ASSERT_TRUE(metadata_->GetCacheEntry(
+      test_resource_id, test_file_md5, &cache_entry));
+  EXPECT_EQ(test_file_md5, cache_entry.md5());
+  EXPECT_EQ(test_sub_dir_type, GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(test_cache_state, cache_entry.cache_state());
 }
 
 TEST_F(GDataCacheMetadataMapTest, Initialization) {
   using file_util::PathExists;
   using file_util::IsLink;
   SetUpCacheWithVariousFiles();
 
   // Some files are removed during cache initialization. Make sure these
   // exist beforehand.
   EXPECT_TRUE(PathExists(persistent_directory_.AppendASCII("id_baz.local")));
   EXPECT_TRUE(PathExists(persistent_directory_.AppendASCII("id_bad.md5bad")));
   EXPECT_TRUE(PathExists(tmp_directory_.AppendASCII("id_quux.local")));
   EXPECT_TRUE(PathExists(pinned_directory_.AppendASCII("id_not_symlink")));
   EXPECT_TRUE(IsLink(pinned_directory_.AppendASCII("id_dangling")));
   EXPECT_TRUE(IsLink(pinned_directory_.AppendASCII("id_outside")));
   EXPECT_TRUE(IsLink(outgoing_directory_.AppendASCII("id_foo")));
   EXPECT_TRUE(IsLink(persistent_directory_.AppendASCII("id_symlink")));
   EXPECT_TRUE(IsLink(tmp_directory_.AppendASCII("id_symlink_tmp")));
 
   SetUpCacheMetadata();
 
   // Check contents in "persistent" directory.
   //
   // "id_foo" is present and pinned.
-  scoped_ptr<GDataCacheEntry> cache_entry;
-  cache_entry = metadata_->GetCacheEntry("id_foo", "md5foo");
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ("md5foo", cache_entry->md5());
+  GDataCacheEntry cache_entry;
+  ASSERT_TRUE(metadata_->GetCacheEntry("id_foo", "md5foo", &cache_entry));
+  EXPECT_EQ("md5foo", cache_entry.md5());
   EXPECT_EQ(GDataCache::CACHE_TYPE_PERSISTENT,
-            GDataCache::GetSubDirectoryType(*cache_entry));
-  EXPECT_EQ(CACHE_STATE_PRESENT | CACHE_STATE_PINNED |
-            CACHE_STATE_PERSISTENT,
-            cache_entry->cache_state());
+            GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(CACHE_STATE_PRESENT | CACHE_STATE_PINNED | CACHE_STATE_PERSISTENT,
+            cache_entry.cache_state());
   EXPECT_TRUE(PathExists(persistent_directory_.AppendASCII("id_foo.md5foo")));
   EXPECT_TRUE(PathExists(pinned_directory_.AppendASCII("id_foo")));
   // The invalid symlink in "outgoing" should be removed.
   EXPECT_FALSE(PathExists(outgoing_directory_.AppendASCII("id_foo")));
 
   // "id_bar" is present and dirty.
-  cache_entry = metadata_->GetCacheEntry("id_bar", "");
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ("local", cache_entry->md5());
+  ASSERT_TRUE(metadata_->GetCacheEntry("id_bar", "", &cache_entry));
+  EXPECT_EQ("local", cache_entry.md5());
   EXPECT_EQ(GDataCache::CACHE_TYPE_PERSISTENT,
-            GDataCache::GetSubDirectoryType(*cache_entry));
-  EXPECT_EQ(CACHE_STATE_PRESENT | CACHE_STATE_DIRTY |
-            CACHE_STATE_PERSISTENT,
-            cache_entry->cache_state());
+            GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(CACHE_STATE_PRESENT | CACHE_STATE_DIRTY | CACHE_STATE_PERSISTENT,
+            cache_entry.cache_state());
   EXPECT_TRUE(PathExists(persistent_directory_.AppendASCII("id_bar.local")));
   EXPECT_TRUE(PathExists(outgoing_directory_.AppendASCII("id_bar")));
 
   // "id_baz" should be removed during cache initialization.
-  cache_entry = metadata_->GetCacheEntry("id_baz", "");
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry("id_baz", "", &cache_entry));
   EXPECT_FALSE(PathExists(persistent_directory_.AppendASCII("id_baz.local")));
 
   // "id_bad" should be removed during cache initialization.
-  cache_entry = metadata_->GetCacheEntry("id_bad", "md5bad");
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry("id_bad", "md5bad", &cache_entry));
   EXPECT_FALSE(PathExists(persistent_directory_.AppendASCII("id_bad.md5bad")));
 
   // "id_symlink" should be removed during cache initialization.
-  cache_entry = metadata_->GetCacheEntry("id_symlink", "");
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry("id_symlink", "", &cache_entry));
   EXPECT_FALSE(PathExists(persistent_directory_.AppendASCII("id_symlink")));
 
   // Check contents in "tmp" directory.
   //
   // "id_qux" is just present in tmp directory.
-  cache_entry = metadata_->GetCacheEntry("id_qux", "md5qux");
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ("md5qux", cache_entry->md5());
+  ASSERT_TRUE(metadata_->GetCacheEntry("id_qux", "md5qux", &cache_entry));
+  EXPECT_EQ("md5qux", cache_entry.md5());
   EXPECT_EQ(GDataCache::CACHE_TYPE_TMP,
-            GDataCache::GetSubDirectoryType(*cache_entry));
-  EXPECT_EQ(CACHE_STATE_PRESENT, cache_entry->cache_state());
+            GDataCache::GetSubDirectoryType(cache_entry));
+  EXPECT_EQ(CACHE_STATE_PRESENT, cache_entry.cache_state());
   EXPECT_TRUE(PathExists(tmp_directory_.AppendASCII("id_qux.md5qux")));
 
   // "id_quux" should be removed during cache initialization.
-  cache_entry = metadata_->GetCacheEntry("id_quux", "md5qux");
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry("id_quux", "md5qux", &cache_entry));
   EXPECT_FALSE(PathExists(pinned_directory_.AppendASCII("id_quux.local")));
 
   // "id_symlink_tmp" should be removed during cache initialization.
-  cache_entry = metadata_->GetCacheEntry("id_symlink_tmp", "");
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry("id_symlink_tmp", "", &cache_entry));
   EXPECT_FALSE(PathExists(pinned_directory_.AppendASCII("id_symlink_tmp")));
 
   // Check contents in "pinned" directory.
   //
   // "id_corge" is pinned but not present.
-  cache_entry = metadata_->GetCacheEntry("id_corge", "");
-  ASSERT_TRUE(cache_entry.get());
-  EXPECT_EQ("", cache_entry->md5());
-  EXPECT_EQ(CACHE_STATE_PINNED, cache_entry->cache_state());
+  ASSERT_TRUE(metadata_->GetCacheEntry("id_corge", "", &cache_entry));
+  EXPECT_EQ("", cache_entry.md5());
+  EXPECT_EQ(CACHE_STATE_PINNED, cache_entry.cache_state());
   EXPECT_TRUE(IsLink(pinned_directory_.AppendASCII("id_corge")));
 
   // "id_dangling" should be removed during cache initialization.
-  cache_entry = metadata_->GetCacheEntry("id_dangling", "");
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry("id_dangling", "", &cache_entry));
   EXPECT_FALSE(IsLink(pinned_directory_.AppendASCII("id_dangling")));
 
   // "id_outside" should be removed during cache initialization.
-  cache_entry = metadata_->GetCacheEntry("id_outside", "");
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry("id_outside", "", &cache_entry));
   EXPECT_FALSE(IsLink(pinned_directory_.AppendASCII("id_outside")));
 
   // "id_not_symlink" should be removed during cache initialization.
-  cache_entry = metadata_->GetCacheEntry("id_not_symlink", "");
-  EXPECT_FALSE(cache_entry.get());
+  EXPECT_FALSE(metadata_->GetCacheEntry("id_not_symlink", "", &cache_entry));
   EXPECT_FALSE(IsLink(pinned_directory_.AppendASCII("id_not_symlink")));
 }
 
 // Test GDataCacheMetadataMap::RemoveTemporaryFiles.
 TEST_F(GDataCacheMetadataMapTest, RemoveTemporaryFilesTest) {
   SetUpCacheMetadata();
 
   GDataCacheMetadataMap::CacheMap cache_map;
   InsertIntoMap(&cache_map,
                 "<resource_id_1>",
                 "<md5>",
                 CACHE_STATE_PRESENT);
   InsertIntoMap(&cache_map,
                 "<resource_id_2>",
                 "<md5>",
-                CACHE_STATE_PRESENT |
-                CACHE_STATE_PERSISTENT);
+                CACHE_STATE_PRESENT | CACHE_STATE_PERSISTENT);
   InsertIntoMap(&cache_map,
                 "<resource_id_3>",
                 "<md5>",
-                CACHE_STATE_PRESENT |
-                CACHE_STATE_PERSISTENT);
+                CACHE_STATE_PRESENT | CACHE_STATE_PERSISTENT);
   InsertIntoMap(&cache_map,
                 "<resource_id_4>",
                 "<md5>",
                 CACHE_STATE_PRESENT);
 
   metadata_->cache_map_ = cache_map;
   metadata_->RemoveTemporaryFiles();
   // resource 1 and 4 should be gone, as these are temporary.
-  EXPECT_FALSE(metadata_->GetCacheEntry("<resource_id_1>", "").get());
-  EXPECT_TRUE(metadata_->GetCacheEntry("<resource_id_2>", "").get());
-  EXPECT_TRUE(metadata_->GetCacheEntry("<resource_id_3>", "").get());
-  EXPECT_FALSE(metadata_->GetCacheEntry("<resource_id_4>", "").get());
+  GDataCacheEntry cache_entry;
+  EXPECT_FALSE(metadata_->GetCacheEntry("<resource_id_1>", "", &cache_entry));
+  EXPECT_TRUE(metadata_->GetCacheEntry("<resource_id_2>", "", &cache_entry));
+  EXPECT_TRUE(metadata_->GetCacheEntry("<resource_id_3>", "", &cache_entry));
+  EXPECT_FALSE(metadata_->GetCacheEntry("<resource_id_4>", "", &cache_entry));
 }
 
 }  // namespace gdata