Convert //google_apis from scoped_ptr to std::unique_ptr

google_apis/drive/drive_api_parser.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 "google_apis/drive/drive_api_parser.h"
 
 #include <stddef.h>
 
+#include <memory>
+
 #include "base/json/json_value_converter.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "google_apis/drive/time_util.h"
 
 namespace google_apis {
 
 namespace {
 
 const int64_t kUnsetFileSize = -1;
 
 bool CreateFileResourceFromValue(const base::Value* value,
-                                 scoped_ptr<FileResource>* file) {
+                                 std::unique_ptr<FileResource>* file) {
   *file = FileResource::CreateFrom(*value);
   return !!*file;
 }
 
 // Converts |url_string| to |result|.  Always returns true to be used
 // for JSONValueConverter::RegisterCustomField method.
 // TODO(mukai): make it return false in case of invalid |url_string|.
 bool GetGURLFromString(const base::StringPiece& url_string, GURL* result) {
   *result = GURL(url_string.as_string());
   return true;
@@ skipping 173 matching lines @@
 // AboutResource implementation
 
 AboutResource::AboutResource()
     : largest_change_id_(0),
       quota_bytes_total_(0),
       quota_bytes_used_aggregate_(0) {}
 
 AboutResource::~AboutResource() {}
 
 // static
-scoped_ptr<AboutResource> AboutResource::CreateFrom(const base::Value& value) {
-  scoped_ptr<AboutResource> resource(new AboutResource());
+std::unique_ptr<AboutResource> AboutResource::CreateFrom(
+    const base::Value& value) {
+  std::unique_ptr<AboutResource> resource(new AboutResource());
   if (!IsResourceKindExpected(value, kAboutKind) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid About resource JSON!";
-    return scoped_ptr<AboutResource>();
+    return std::unique_ptr<AboutResource>();
   }
   return resource;
 }
 
 // static
 void AboutResource::RegisterJSONConverter(
     base::JSONValueConverter<AboutResource>* converter) {
   converter->RegisterCustomField<int64_t>(kLargestChangeId,
                                           &AboutResource::largest_change_id_,
                                           &base::StringToInt64);
@@ skipping 30 matching lines @@
       kCategory,
       &DriveAppIcon::category_,
       &DriveAppIcon::GetIconCategory);
   converter->RegisterIntField(kSize, &DriveAppIcon::icon_side_length_);
   converter->RegisterCustomField<GURL>(kIconUrl,
                                        &DriveAppIcon::icon_url_,
                                        GetGURLFromString);
 }
 
 // static
-scoped_ptr<DriveAppIcon> DriveAppIcon::CreateFrom(const base::Value& value) {
-  scoped_ptr<DriveAppIcon> resource(new DriveAppIcon());
+std::unique_ptr<DriveAppIcon> DriveAppIcon::CreateFrom(
+    const base::Value& value) {
+  std::unique_ptr<DriveAppIcon> resource(new DriveAppIcon());
   if (!resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid DriveAppIcon JSON!";
-    return scoped_ptr<DriveAppIcon>();
+    return std::unique_ptr<DriveAppIcon>();
   }
   return resource;
 }
 
 bool DriveAppIcon::Parse(const base::Value& value) {
   base::JSONValueConverter<DriveAppIcon> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid DriveAppIcon";
     return false;
   }
@@ skipping 40 matching lines @@
                                     &AppResource::primary_file_extensions_);
   converter->RegisterRepeatedString(kSecondaryFileExtensions,
                                     &AppResource::secondary_file_extensions_);
   converter->RegisterRepeatedMessage(kIcons, &AppResource::icons_);
   converter->RegisterCustomField<GURL>(kCreateUrl,
                                        &AppResource::create_url_,
                                        GetGURLFromString);
 }
 
 // static
-scoped_ptr<AppResource> AppResource::CreateFrom(const base::Value& value) {
-  scoped_ptr<AppResource> resource(new AppResource());
+std::unique_ptr<AppResource> AppResource::CreateFrom(const base::Value& value) {
+  std::unique_ptr<AppResource> resource(new AppResource());
   if (!IsResourceKindExpected(value, kAppKind) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid AppResource JSON!";
-    return scoped_ptr<AppResource>();
+    return std::unique_ptr<AppResource>();
   }
   return resource;
 }
 
 bool AppResource::Parse(const base::Value& value) {
   base::JSONValueConverter<AppResource> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid AppResource";
     return false;
   }
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AppList implementation
 
 AppList::AppList() {}
 
 AppList::~AppList() {}
 
 // static
 void AppList::RegisterJSONConverter(
     base::JSONValueConverter<AppList>* converter) {
   converter->RegisterStringField(kETag, &AppList::etag_);
   converter->RegisterRepeatedMessage<AppResource>(kItems,
                                                    &AppList::items_);
 }
 
 // static
-scoped_ptr<AppList> AppList::CreateFrom(const base::Value& value) {
-  scoped_ptr<AppList> resource(new AppList());
+std::unique_ptr<AppList> AppList::CreateFrom(const base::Value& value) {
+  std::unique_ptr<AppList> resource(new AppList());
   if (!IsResourceKindExpected(value, kAppListKind) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid AppList JSON!";
-    return scoped_ptr<AppList>();
+    return std::unique_ptr<AppList>();
   }
   return resource;
 }
 
 bool AppList::Parse(const base::Value& value) {
   base::JSONValueConverter<AppList> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid AppList";
     return false;
   }
@@ skipping 10 matching lines @@
 // static
 void ParentReference::RegisterJSONConverter(
     base::JSONValueConverter<ParentReference>* converter) {
   converter->RegisterStringField(kId, &ParentReference::file_id_);
   converter->RegisterCustomField<GURL>(kParentLink,
                                        &ParentReference::parent_link_,
                                        GetGURLFromString);
 }
 
 // static
-scoped_ptr<ParentReference>
-ParentReference::CreateFrom(const base::Value& value) {
-  scoped_ptr<ParentReference> reference(new ParentReference());
+std::unique_ptr<ParentReference> ParentReference::CreateFrom(
+    const base::Value& value) {
+  std::unique_ptr<ParentReference> reference(new ParentReference());
   if (!IsResourceKindExpected(value, kParentReferenceKind) ||
       !reference->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid ParentRefernce JSON!";
-    return scoped_ptr<ParentReference>();
+    return std::unique_ptr<ParentReference>();
   }
   return reference;
 }
 
 bool ParentReference::Parse(const base::Value& value) {
   base::JSONValueConverter<ParentReference> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid ParentReference";
     return false;
   }
@@ skipping 49 matching lines @@
       kParents,
       &FileResource::parents_,
       GetParentsFromValue);
   converter->RegisterCustomValueField<std::vector<OpenWithLink> >(
       kOpenWithLinks,
       &FileResource::open_with_links_,
       GetOpenWithLinksFromDictionaryValue);
 }
 
 // static
-scoped_ptr<FileResource> FileResource::CreateFrom(const base::Value& value) {
-  scoped_ptr<FileResource> resource(new FileResource());
+std::unique_ptr<FileResource> FileResource::CreateFrom(
+    const base::Value& value) {
+  std::unique_ptr<FileResource> resource(new FileResource());
   if (!IsResourceKindExpected(value, kFileKind) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid FileResource JSON!";
-    return scoped_ptr<FileResource>();
+    return std::unique_ptr<FileResource>();
   }
   return resource;
 }
 
 bool FileResource::IsDirectory() const {
   return mime_type_ == kDriveFolderMimeType;
 }
 
 bool FileResource::IsHostedDocument() const {
   // Hosted documents don't have fileSize field set:
@@ skipping 26 matching lines @@
   converter->RegisterRepeatedMessage<FileResource>(kItems,
                                                    &FileList::items_);
 }
 
 // static
 bool FileList::HasFileListKind(const base::Value& value) {
   return IsResourceKindExpected(value, kFileListKind);
 }
 
 // static
-scoped_ptr<FileList> FileList::CreateFrom(const base::Value& value) {
-  scoped_ptr<FileList> resource(new FileList());
+std::unique_ptr<FileList> FileList::CreateFrom(const base::Value& value) {
+  std::unique_ptr<FileList> resource(new FileList());
   if (!HasFileListKind(value) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid FileList JSON!";
-    return scoped_ptr<FileList>();
+    return std::unique_ptr<FileList>();
   }
   return resource;
 }
 
 bool FileList::Parse(const base::Value& value) {
   base::JSONValueConverter<FileList> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid FileList";
     return false;
   }
@@ skipping 15 matching lines @@
   converter->RegisterStringField(kFileId, &ChangeResource::file_id_);
   converter->RegisterBoolField(kDeleted, &ChangeResource::deleted_);
   converter->RegisterCustomValueField(kFile, &ChangeResource::file_,
                                       &CreateFileResourceFromValue);
   converter->RegisterCustomField<base::Time>(
       kModificationDate, &ChangeResource::modification_date_,
       &util::GetTimeFromString);
 }
 
 // static
-scoped_ptr<ChangeResource>
-ChangeResource::CreateFrom(const base::Value& value) {
-  scoped_ptr<ChangeResource> resource(new ChangeResource());
+std::unique_ptr<ChangeResource> ChangeResource::CreateFrom(
+    const base::Value& value) {
+  std::unique_ptr<ChangeResource> resource(new ChangeResource());
   if (!IsResourceKindExpected(value, kChangeKind) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid ChangeResource JSON!";
-    return scoped_ptr<ChangeResource>();
+    return std::unique_ptr<ChangeResource>();
   }
   return resource;
 }
 
 bool ChangeResource::Parse(const base::Value& value) {
   base::JSONValueConverter<ChangeResource> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid ChangeResource";
     return false;
   }
@@ skipping 18 matching lines @@
   converter->RegisterRepeatedMessage<ChangeResource>(kItems,
                                                      &ChangeList::items_);
 }
 
 // static
 bool ChangeList::HasChangeListKind(const base::Value& value) {
   return IsResourceKindExpected(value, kChangeListKind);
 }
 
 // static
-scoped_ptr<ChangeList> ChangeList::CreateFrom(const base::Value& value) {
-  scoped_ptr<ChangeList> resource(new ChangeList());
+std::unique_ptr<ChangeList> ChangeList::CreateFrom(const base::Value& value) {
+  std::unique_ptr<ChangeList> resource(new ChangeList());
   if (!HasChangeListKind(value) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid ChangeList JSON!";
-    return scoped_ptr<ChangeList>();
+    return std::unique_ptr<ChangeList>();
   }
   return resource;
 }
 
 bool ChangeList::Parse(const base::Value& value) {
   base::JSONValueConverter<ChangeList> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid ChangeList";
     return false;
   }
   return true;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // FileLabels implementation
 
 FileLabels::FileLabels() : trashed_(false) {}
 
 FileLabels::~FileLabels() {}
 
 // static
 void FileLabels::RegisterJSONConverter(
     base::JSONValueConverter<FileLabels>* converter) {
   converter->RegisterBoolField(kLabelTrashed, &FileLabels::trashed_);
 }
 
 // static
-scoped_ptr<FileLabels> FileLabels::CreateFrom(const base::Value& value) {
-  scoped_ptr<FileLabels> resource(new FileLabels());
+std::unique_ptr<FileLabels> FileLabels::CreateFrom(const base::Value& value) {
+  std::unique_ptr<FileLabels> resource(new FileLabels());
   if (!resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid FileLabels JSON!";
-    return scoped_ptr<FileLabels>();
+    return std::unique_ptr<FileLabels>();
   }
   return resource;
 }
 
 bool FileLabels::Parse(const base::Value& value) {
   base::JSONValueConverter<FileLabels> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid FileLabels.";
     return false;
   }
@@ skipping 15 matching lines @@
     base::JSONValueConverter<ImageMediaMetadata>* converter) {
   converter->RegisterIntField(kImageMediaMetadataWidth,
                               &ImageMediaMetadata::width_);
   converter->RegisterIntField(kImageMediaMetadataHeight,
                               &ImageMediaMetadata::height_);
   converter->RegisterIntField(kImageMediaMetadataRotation,
                               &ImageMediaMetadata::rotation_);
 }
 
 // static
-scoped_ptr<ImageMediaMetadata> ImageMediaMetadata::CreateFrom(
+std::unique_ptr<ImageMediaMetadata> ImageMediaMetadata::CreateFrom(
     const base::Value& value) {
-  scoped_ptr<ImageMediaMetadata> resource(new ImageMediaMetadata());
+  std::unique_ptr<ImageMediaMetadata> resource(new ImageMediaMetadata());
   if (!resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid ImageMediaMetadata JSON!";
-    return scoped_ptr<ImageMediaMetadata>();
+    return std::unique_ptr<ImageMediaMetadata>();
   }
   return resource;
 }
 
 bool ImageMediaMetadata::Parse(const base::Value& value) {
   base::JSONValueConverter<ImageMediaMetadata> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid ImageMediaMetadata.";
     return false;
   }
   return true;
 }
 
 }  // namespace google_apis