Remove parent* arg from GDataEntry ctor.

chrome/browser/chromeos/gdata/gdata_files_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_files.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 14 matching lines @@
 
 // See gdata.proto for the difference between the two URLs.
 const char kResumableEditMediaUrl[] = "http://resumable-edit-media/";
 const char kResumableCreateMediaUrl[] = "http://resumable-create-media/";
 
 // Add a directory to |parent| and return that directory. The name and
 // resource_id are determined by the incrementing counter |sequence_id|.
 GDataDirectory* AddDirectory(GDataDirectory* parent,
                              GDataDirectoryService* directory_service,
                              int sequence_id) {
-  GDataDirectory* dir = new GDataDirectory(NULL, directory_service);
+  GDataDirectory* dir = directory_service->CreateGDataDirectory();
   const std::string dir_name = "dir" + base::IntToString(sequence_id);
   const std::string resource_id = std::string("dir_resource_id:") +
                                   dir_name;
   dir->set_title(dir_name);
   dir->set_resource_id(resource_id);
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   FilePath moved_file_path;
   directory_service->MoveEntryToDirectory(
       parent->GetFilePath(),
       dir,
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error,
                  &moved_file_path));
   test_util::RunBlockingPoolTask();
   EXPECT_EQ(GDATA_FILE_OK, error);
   EXPECT_EQ(parent->GetFilePath().AppendASCII(dir_name), moved_file_path);
   return dir;
 }
 
 // Add a file to |parent| and return that file. The name and
 // resource_id are determined by the incrementing counter |sequence_id|.
 GDataFile* AddFile(GDataDirectory* parent,
                    GDataDirectoryService* directory_service,
                    int sequence_id) {
-  GDataFile* file = new GDataFile(NULL, directory_service);
+  GDataFile* file = directory_service->CreateGDataFile();
   const std::string title = "file" + base::IntToString(sequence_id);
   const std::string resource_id = std::string("file_resource_id:") +
                                   title;
   file->set_title(title);
   file->set_resource_id(resource_id);
   file->set_file_md5(std::string("file_md5:") + title);
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   FilePath moved_file_path;
   directory_service->MoveEntryToDirectory(
       parent->GetFilePath(),
@@ skipping 117 matching lines @@
                         GDataFileError actual_error) {
   EXPECT_EQ(expected_error, actual_error);
 }
 
 }  // namespace
 
 TEST(GDataEntryTest, FromProto_DetectBadUploadUrl) {
   GDataEntryProto proto;
   proto.set_title("test.txt");
 
-  GDataEntry entry(NULL, NULL);
+  GDataDirectoryService directory_service;
+
+  scoped_ptr<GDataEntry> entry(directory_service.CreateGDataFile());
   // This should fail as the upload URL is empty.
-  ASSERT_FALSE(entry.FromProto(proto));
+  ASSERT_FALSE(entry->FromProto(proto));
 
   // Set a upload URL.
   proto.set_upload_url(kResumableEditMediaUrl);
 
   // This should succeed as the upload URL is set.
-  ASSERT_TRUE(entry.FromProto(proto));
-  EXPECT_EQ(kResumableEditMediaUrl, entry.upload_url().spec());
+  ASSERT_TRUE(entry->FromProto(proto));
+  EXPECT_EQ(kResumableEditMediaUrl, entry->upload_url().spec());
 }
 
 TEST(GDataDirectoryServiceTest, VersionCheck) {
   // Set up the root directory.
   GDataRootDirectoryProto proto;
   GDataEntryProto* mutable_entry =
       proto.mutable_gdata_directory()->mutable_gdata_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_resource_id(kGDataRootDirectoryResourceId);
   mutable_entry->set_upload_url(kResumableCreateMediaUrl);
@@ skipping 162 matching lines @@
   ASSERT_EQ(FROM_CACHE, directory_service.origin());
 }
 
 TEST(GDataDirectoryServiceTest, RefreshFile) {
   MessageLoopForUI message_loop;
   content::TestBrowserThread ui_thread(content::BrowserThread::UI,
                                        &message_loop);
 
   GDataDirectoryService directory_service;
   // Add a directory to the file system.
-  GDataDirectory* directory_entry = new GDataDirectory(NULL,
-                                                       &directory_service);
+  GDataDirectory* directory_entry = directory_service.CreateGDataDirectory();
   directory_entry->set_resource_id("folder:directory_resource_id");
   directory_entry->set_title("directory");
   directory_entry->SetBaseNameFromTitle();
   GDataFileError error = GDATA_FILE_ERROR_FAILED;
   FilePath moved_file_path;
   FilePath root_path(kGDataRootDirectory);
   directory_service.MoveEntryToDirectory(
       root_path,
       directory_entry,
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error,
                  &moved_file_path));
   test_util::RunBlockingPoolTask();
   ASSERT_EQ(GDATA_FILE_OK, error);
   EXPECT_EQ(root_path.AppendASCII(directory_entry->base_name()),
             moved_file_path);
 
   // Add a new file to the directory.
-  GDataFile* initial_file_entry = new GDataFile(NULL, &directory_service);
+  GDataFile* initial_file_entry = directory_service.CreateGDataFile();
   initial_file_entry->set_resource_id("file:file_resource_id");
   initial_file_entry->set_title("file");
   initial_file_entry->SetBaseNameFromTitle();
   error = GDATA_FILE_ERROR_FAILED;
   moved_file_path.clear();
   directory_service.MoveEntryToDirectory(
       directory_entry->GetFilePath(),
       initial_file_entry,
       base::Bind(&test_util::CopyResultsFromFileMoveCallback,
                  &error,
                  &moved_file_path));
   test_util::RunBlockingPoolTask();
   ASSERT_EQ(GDATA_FILE_OK, error);
   EXPECT_EQ(directory_entry->GetFilePath().AppendASCII(
                 initial_file_entry->base_name()), moved_file_path);
 
   ASSERT_EQ(directory_entry, initial_file_entry->parent());
 
   // Initial file system state set, let's try refreshing entries.
 
   // New value for the entry with resource id "file:file_resource_id".
-  GDataFile* new_file_entry = new GDataFile(NULL, &directory_service);
+  GDataFile* new_file_entry = directory_service.CreateGDataFile();
   new_file_entry->set_resource_id("file:file_resource_id");
   directory_service.RefreshFile(scoped_ptr<GDataFile>(new_file_entry).Pass());
   // Root should have |new_file_entry|, not |initial_file_entry|.
   // If this is not true, |new_file_entry| has probably been destroyed, hence
   // ASSERT (we're trying to access |new_file_entry| later on).
   ASSERT_EQ(new_file_entry,
       directory_service.GetEntryByResourceId("file:file_resource_id"));
   // We have just verified new_file_entry exists inside root, so accessing
   // |new_file_entry->parent()| should be safe.
   EXPECT_EQ(directory_entry, new_file_entry->parent());
 
   // Let's try refreshing file that didn't prviously exist.
-  GDataFile* non_existent_entry = new GDataFile(NULL, &directory_service);
+  GDataFile* non_existent_entry = directory_service.CreateGDataFile();
   non_existent_entry->set_resource_id("file:does_not_exist");
   directory_service.RefreshFile(
       scoped_ptr<GDataFile>(non_existent_entry).Pass());
   // File with non existent resource id should not be added.
   EXPECT_FALSE(directory_service.GetEntryByResourceId("file:does_not_exist"));
 }
 
 TEST(GDataDirectoryServiceTest, GetEntryByResourceId_RootDirectory) {
   GDataDirectoryService directory_service;
   // Look up the root directory by its resource ID.
@@ skipping 181 matching lines @@
   GDataDirectoryService directory_service2;
   // InitFromDB should succeed with GDATA_FILE_OK as the db now exists.
   directory_service2.InitFromDB(db_path, blocking_task_runner,
       base::Bind(&InitFromDBCallback, GDATA_FILE_OK));
   test_util::RunBlockingPoolTask();
 
   VerifyDirectoryService(&directory_service2);
 }
 
 }  // namespace gdata