Convert Pass()→std::move() in //google_apis

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 "base/json/json_value_converter.h"
 #include "base/macros.h"
@@ skipping 204 matching lines @@
 
 AboutResource::~AboutResource() {}
 
 // static
 scoped_ptr<AboutResource> AboutResource::CreateFrom(const base::Value& value) {
   scoped_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 resource.Pass();
+  return resource;
 }
 
 // static
 void AboutResource::RegisterJSONConverter(
     base::JSONValueConverter<AboutResource>* converter) {
   converter->RegisterCustomField<int64_t>(kLargestChangeId,
                                           &AboutResource::largest_change_id_,
                                           &base::StringToInt64);
   converter->RegisterCustomField<int64_t>(kQuotaBytesTotal,
                                           &AboutResource::quota_bytes_total_,
@@ skipping 34 matching lines @@
                                        GetGURLFromString);
 }
 
 // static
 scoped_ptr<DriveAppIcon> DriveAppIcon::CreateFrom(const base::Value& value) {
   scoped_ptr<DriveAppIcon> resource(new DriveAppIcon());
   if (!resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid DriveAppIcon JSON!";
     return scoped_ptr<DriveAppIcon>();
   }
-  return resource.Pass();
+  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;
   }
   return true;
 }
@@ skipping 44 matching lines @@
                                        GetGURLFromString);
 }
 
 // static
 scoped_ptr<AppResource> AppResource::CreateFrom(const base::Value& value) {
   scoped_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 resource.Pass();
+  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;
 }
@@ skipping 13 matching lines @@
                                                    &AppList::items_);
 }
 
 // static
 scoped_ptr<AppList> AppList::CreateFrom(const base::Value& value) {
   scoped_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 resource.Pass();
+  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;
   }
   return true;
 }
@@ skipping 16 matching lines @@
 
 // static
 scoped_ptr<ParentReference>
 ParentReference::CreateFrom(const base::Value& value) {
   scoped_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 reference.Pass();
+  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;
   }
   return true;
 }
@@ skipping 51 matching lines @@
       GetOpenWithLinksFromDictionaryValue);
 }
 
 // static
 scoped_ptr<FileResource> FileResource::CreateFrom(const base::Value& value) {
   scoped_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 resource.Pass();
+  return resource;
 }
 
 bool FileResource::IsDirectory() const {
   return mime_type_ == kDriveFolderMimeType;
 }
 
 bool FileResource::IsHostedDocument() const {
   // Hosted documents don't have fileSize field set:
   // https://developers.google.com/drive/v2/reference/files
   return !IsDirectory() && file_size_ == kUnsetFileSize;
@@ skipping 30 matching lines @@
   return IsResourceKindExpected(value, kFileListKind);
 }
 
 // static
 scoped_ptr<FileList> FileList::CreateFrom(const base::Value& value) {
   scoped_ptr<FileList> resource(new FileList());
   if (!HasFileListKind(value) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid FileList JSON!";
     return scoped_ptr<FileList>();
   }
-  return resource.Pass();
+  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;
   }
   return true;
 }
@@ skipping 20 matching lines @@
 }
 
 // static
 scoped_ptr<ChangeResource>
 ChangeResource::CreateFrom(const base::Value& value) {
   scoped_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 resource.Pass();
+  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;
   }
   return true;
 }
@@ skipping 22 matching lines @@
   return IsResourceKindExpected(value, kChangeListKind);
 }
 
 // static
 scoped_ptr<ChangeList> ChangeList::CreateFrom(const base::Value& value) {
   scoped_ptr<ChangeList> resource(new ChangeList());
   if (!HasChangeListKind(value) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid ChangeList JSON!";
     return scoped_ptr<ChangeList>();
   }
-  return resource.Pass();
+  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;
 }
@@ skipping 12 matching lines @@
   converter->RegisterBoolField(kLabelTrashed, &FileLabels::trashed_);
 }
 
 // static
 scoped_ptr<FileLabels> FileLabels::CreateFrom(const base::Value& value) {
   scoped_ptr<FileLabels> resource(new FileLabels());
   if (!resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid FileLabels JSON!";
     return scoped_ptr<FileLabels>();
   }
-  return resource.Pass();
+  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;
   }
   return true;
 }
@@ skipping 20 matching lines @@
 }
 
 // static
 scoped_ptr<ImageMediaMetadata> ImageMediaMetadata::CreateFrom(
     const base::Value& value) {
   scoped_ptr<ImageMediaMetadata> resource(new ImageMediaMetadata());
   if (!resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid ImageMediaMetadata JSON!";
     return scoped_ptr<ImageMediaMetadata>();
   }
-  return resource.Pass();
+  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