Convert //sync from scoped_ptr to std::unique_ptr

sync/engine/directory_update_handler_unittest.cc

 // Copyright 2014 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 "sync/engine/directory_update_handler.h"
 
 #include <stdint.h>
 
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "sync/engine/syncer_proto_util.h"
 #include "sync/internal_api/public/base/attachment_id_proto.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/test/test_entry_factory.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/sessions/directory_type_debug_info_emitter.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/entry.h"
@@ skipping 30 matching lines @@
 
   void SetUp() override { dir_maker_.SetUp(); }
 
   void TearDown() override { dir_maker_.TearDown(); }
 
   syncable::Directory* dir() {
     return dir_maker_.directory();
   }
 
  protected:
-  scoped_ptr<sync_pb::SyncEntity> CreateUpdate(
-      const std::string& id,
-      const std::string& parent,
-      const ModelType& type);
+  std::unique_ptr<sync_pb::SyncEntity> CreateUpdate(const std::string& id,
+                                                    const std::string& parent,
+                                                    const ModelType& type);
 
   // This exists mostly to give tests access to the protected member function.
   // Warning: This takes the syncable directory lock.
   void UpdateSyncEntities(
       DirectoryUpdateHandler* handler,
       const SyncEntityList& applicable_updates,
       sessions::StatusController* status);
 
   // Another function to access private member functions.
   void UpdateProgressMarkers(
@@ skipping 18 matching lines @@
  protected:
   // Used in the construction of DirectoryTypeDebugInfoEmitters.
   base::ObserverList<TypeDebugInfoObserver> type_observers_;
 
  private:
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
   scoped_refptr<FakeModelWorker> ui_worker_;
 };
 
-scoped_ptr<sync_pb::SyncEntity>
-DirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(
-    const std::string& id,
-    const std::string& parent,
-    const ModelType& type) {
-  scoped_ptr<sync_pb::SyncEntity> e(new sync_pb::SyncEntity());
+std::unique_ptr<sync_pb::SyncEntity>
+DirectoryUpdateHandlerProcessUpdateTest::CreateUpdate(const std::string& id,
+                                                      const std::string& parent,
+                                                      const ModelType& type) {
+  std::unique_ptr<sync_pb::SyncEntity> e(new sync_pb::SyncEntity());
   e->set_id_string(id);
   e->set_parent_id_string(parent);
   e->set_non_unique_name(id);
   e->set_name(id);
   e->set_version(kDefaultVersion);
   AddDefaultFieldValue(type, e->mutable_specifics());
   return e;
 }
 
 void DirectoryUpdateHandlerProcessUpdateTest::UpdateSyncEntities(
@@ skipping 15 matching lines @@
 // Test that the bookmark tag is set on newly downloaded items.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, NewBookmarkTag) {
   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Add a bookmark item to the update message.
   std::string root = Id::GetRoot().GetServerId();
   Id server_id = Id::CreateFromServerId("b1");
-  scoped_ptr<sync_pb::SyncEntity> e =
+  std::unique_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_originator_cache_guid(
       std::string(kCacheGuid, arraysize(kCacheGuid)-1));
   Id client_id = Id::CreateFromClientString("-2");
   e->set_originator_client_item_id(client_id.GetServerId());
   e->set_position_in_parent(0);
 
   // Add it to the applicable updates list.
   SyncEntityList bookmark_updates;
   bookmark_updates.push_back(e.get());
@@ skipping 18 matching lines @@
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest,
        ReceiveServerCreatedBookmarkFolders) {
   DirectoryTypeDebugInfoEmitter emitter(BOOKMARKS, &type_observers_);
   DirectoryUpdateHandler handler(dir(), BOOKMARKS, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   // Create an update that mimics the bookmark root.
   Id server_id = Id::CreateFromServerId("xyz");
   std::string root = Id::GetRoot().GetServerId();
-  scoped_ptr<sync_pb::SyncEntity> e =
+  std::unique_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, BOOKMARKS);
   e->set_server_defined_unique_tag("google_chrome_bookmarks");
   e->set_folder(true);
 
   // Add it to the applicable updates list.
   SyncEntityList bookmark_updates;
   bookmark_updates.push_back(e.get());
 
   EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e));
 
@@ skipping 13 matching lines @@
 
 // Test the receipt of a non-bookmark item.
 TEST_F(DirectoryUpdateHandlerProcessUpdateTest, ReceiveNonBookmarkItem) {
   DirectoryTypeDebugInfoEmitter emitter(AUTOFILL, &type_observers_);
   DirectoryUpdateHandler handler(dir(), AUTOFILL, ui_worker(), &emitter);
   sync_pb::GetUpdatesResponse gu_response;
   sessions::StatusController status;
 
   std::string root = Id::GetRoot().GetServerId();
   Id server_id = Id::CreateFromServerId("xyz");
-  scoped_ptr<sync_pb::SyncEntity> e =
+  std::unique_ptr<sync_pb::SyncEntity> e =
       CreateUpdate(SyncableIdToProto(server_id), root, AUTOFILL);
   e->set_server_defined_unique_tag("9PGRuKdX5sHyGMB17CvYTXuC43I=");
 
   // Add it to the applicable updates list.
   SyncEntityList autofill_updates;
   autofill_updates.push_back(e.get());
 
   EXPECT_FALSE(SyncerProtoUtil::ShouldMaintainPosition(*e));
 
   // Process it.
@@ skipping 38 matching lines @@
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   progress.set_token("token");
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
 
   sync_pb::DataTypeContext context;
   context.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   context.set_context("context");
   context.set_version(1);
 
-  scoped_ptr<sync_pb::SyncEntity> e1 =
+  std::unique_ptr<sync_pb::SyncEntity> e1 =
       CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e1")), "",
                    SYNCED_NOTIFICATIONS);
 
-  scoped_ptr<sync_pb::SyncEntity> e2 =
+  std::unique_ptr<sync_pb::SyncEntity> e2 =
       CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e2")), "",
                    SYNCED_NOTIFICATIONS);
   e2->set_version(kDefaultVersion + 100);
 
   // Add to the applicable updates list.
   SyncEntityList updates;
   updates.push_back(e1.get());
   updates.push_back(e2.get());
 
   // Process and apply updates.
@@ skipping 27 matching lines @@
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(
       GetSpecificsFieldNumberFromModelType(SYNCED_NOTIFICATIONS));
   progress.set_token("token");
 
   sync_pb::DataTypeContext old_context;
   old_context.set_version(1);
   old_context.set_context("data");
   old_context.set_data_type_id(field_number);
 
-  scoped_ptr<sync_pb::SyncEntity> e1 =
+  std::unique_ptr<sync_pb::SyncEntity> e1 =
       CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e1")), "",
                    SYNCED_NOTIFICATIONS);
 
   SyncEntityList updates;
   updates.push_back(e1.get());
 
   // The first response should be processed fine.
   EXPECT_EQ(SYNCER_OK,
             handler.ProcessGetUpdatesResponse(
                 progress, old_context, updates, &status));
@@ skipping 10 matching lines @@
     trans.directory()->GetDataTypeContext(
         &trans, SYNCED_NOTIFICATIONS, &dir_context);
     EXPECT_EQ(old_context.SerializeAsString(), dir_context.SerializeAsString());
   }
 
   sync_pb::DataTypeContext new_context;
   new_context.set_version(0);
   new_context.set_context("old");
   new_context.set_data_type_id(field_number);
 
-  scoped_ptr<sync_pb::SyncEntity> e2 =
+  std::unique_ptr<sync_pb::SyncEntity> e2 =
       CreateUpdate(SyncableIdToProto(Id::CreateFromServerId("e2")), "",
                    SYNCED_NOTIFICATIONS);
   updates.clear();
   updates.push_back(e2.get());
 
   // The second response, with an old context version, should result in an
   // error and the updates should be dropped.
   EXPECT_EQ(DATATYPE_TRIGGERED_RETRY,
             handler.ProcessGetUpdatesResponse(
                 progress, new_context, updates, &status));
@@ skipping 21 matching lines @@
   sync_pb::DataTypeProgressMarker progress;
   progress.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES));
   progress.set_token("token");
   progress.mutable_gc_directive()->set_version_watermark(kDefaultVersion + 10);
 
   sync_pb::DataTypeContext context;
   context.set_data_type_id(GetSpecificsFieldNumberFromModelType(ARTICLES));
   context.set_context("context");
   context.set_version(1);
 
-  scoped_ptr<sync_pb::SyncEntity> e1 = CreateUpdate(
+  std::unique_ptr<sync_pb::SyncEntity> e1 = CreateUpdate(
       SyncableIdToProto(Id::CreateFromServerId("e1")), "", ARTICLES);
   sync_pb::AttachmentIdProto* attachment_id = e1->add_attachment_id();
   *attachment_id = CreateAttachmentIdProto(0, 0);
 
   SyncEntityList updates;
   updates.push_back(e1.get());
 
   // Process and apply updates.
   EXPECT_EQ(
       SYNCER_OK,
@@ skipping 45 matching lines @@
         bookmarks_emitter_(BOOKMARKS, &type_observers_),
         passwords_emitter_(PASSWORDS, &type_observers_),
         articles_emitter_(ARTICLES, &type_observers_) {}
 
   void SetUp() override {
     dir_maker_.SetUp();
     entry_factory_.reset(new TestEntryFactory(directory()));
 
     update_handler_map_.insert(std::make_pair(
         BOOKMARKS,
-        make_scoped_ptr(new DirectoryUpdateHandler(
+        base::WrapUnique(new DirectoryUpdateHandler(
             directory(), BOOKMARKS, ui_worker_, &bookmarks_emitter_))));
     update_handler_map_.insert(std::make_pair(
         PASSWORDS,
-        make_scoped_ptr(new DirectoryUpdateHandler(
+        base::WrapUnique(new DirectoryUpdateHandler(
             directory(), PASSWORDS, password_worker_, &passwords_emitter_))));
     update_handler_map_.insert(std::make_pair(
-        ARTICLES, make_scoped_ptr(new DirectoryUpdateHandler(
+        ARTICLES, base::WrapUnique(new DirectoryUpdateHandler(
                       directory(), ARTICLES, ui_worker_, &articles_emitter_))));
   }
 
   void TearDown() override { dir_maker_.TearDown(); }
 
   const UpdateCounters& GetBookmarksUpdateCounters() {
     return bookmarks_emitter_.GetUpdateCounters();
   }
 
   const UpdateCounters& GetPasswordsUpdateCounters() {
@@ skipping 21 matching lines @@
     return entry_factory_.get();
   }
 
   syncable::Directory* directory() {
     return dir_maker_.directory();
   }
 
  private:
   base::MessageLoop loop_;  // Needed to initialize the directory.
   TestDirectorySetterUpper dir_maker_;
-  scoped_ptr<TestEntryFactory> entry_factory_;
+  std::unique_ptr<TestEntryFactory> entry_factory_;
 
   scoped_refptr<FakeModelWorker> ui_worker_;
   scoped_refptr<FakeModelWorker> password_worker_;
   scoped_refptr<FakeModelWorker> passive_worker_;
 
   base::ObserverList<TypeDebugInfoObserver> type_observers_;
   DirectoryTypeDebugInfoEmitter bookmarks_emitter_;
   DirectoryTypeDebugInfoEmitter passwords_emitter_;
   DirectoryTypeDebugInfoEmitter articles_emitter_;
 
-  std::map<ModelType, scoped_ptr<UpdateHandler>> update_handler_map_;
+  std::map<ModelType, std::unique_ptr<UpdateHandler>> update_handler_map_;
 };
 
 namespace {
 sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
   sync_pb::EntitySpecifics result;
   AddDefaultFieldValue(BOOKMARKS, &result);
   return result;
 }
 }  // namespace
 
@@ skipping 607 matching lines @@
   const UpdateCounters& counters = GetArticlesUpdateCounters();
   EXPECT_EQ(1, counters.num_updates_applied);
   EXPECT_EQ(1, counters.num_local_overwrites);
   EXPECT_EQ(0, counters.num_server_overwrites);
   local_metadata = entry_factory()->GetLocalAttachmentMetadataForItem(handle);
   EXPECT_EQ(server_metadata.SerializeAsString(),
             local_metadata.SerializeAsString());
 }
 
 }  // namespace syncer