Rewrite scoped_ptr<T>(NULL) to use the default ctor in chrome/.

chrome/browser/google_apis/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 "chrome/browser/google_apis/drive_api_parser.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
@@ skipping 205 matching lines @@
       quota_bytes_total_(0),
       quota_bytes_used_(0) {}
 
 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>(NULL);
+    return scoped_ptr<AboutResource>();
   }
   return resource.Pass();
 }
 
 // static
 scoped_ptr<AboutResource> AboutResource::CreateFromAccountMetadata(
     const AccountMetadata& account_metadata,
     const std::string& root_resource_id) {
   scoped_ptr<AboutResource> resource(new AboutResource);
   resource->set_largest_change_id(account_metadata.largest_changestamp());
@@ skipping 46 matching lines @@
   converter->RegisterCustomField<GURL>(kIconUrl,
                                        &DriveAppIcon::icon_url_,
                                        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>(NULL);
+    return scoped_ptr<DriveAppIcon>();
   }
   return resource.Pass();
 }
 
 // static
 scoped_ptr<DriveAppIcon> DriveAppIcon::CreateFromAppIcon(
     const AppIcon& app_icon) {
   scoped_ptr<DriveAppIcon> resource(new DriveAppIcon);
   switch (app_icon.category()) {
     case AppIcon::ICON_UNKNOWN:
@@ skipping 73 matching lines @@
   converter->RegisterRepeatedString(kSecondaryFileExtensions,
                                     &AppResource::secondary_file_extensions_);
   converter->RegisterRepeatedMessage(kIcons, &AppResource::icons_);
 }
 
 // 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>(NULL);
+    return scoped_ptr<AppResource>();
   }
   return resource.Pass();
 }
 
 // static
 scoped_ptr<AppResource> AppResource::CreateFromInstalledApp(
     const InstalledApp& installed_app) {
   scoped_ptr<AppResource> resource(new AppResource);
   resource->set_application_id(installed_app.app_id());
   resource->set_name(installed_app.app_name());
@@ skipping 61 matching lines @@
   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());
   if (!IsResourceKindExpected(value, kAppListKind) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid AppList JSON!";
-    return scoped_ptr<AppList>(NULL);
+    return scoped_ptr<AppList>();
   }
   return resource.Pass();
 }
 
 // static
 scoped_ptr<AppList> AppList::CreateFromAccountMetadata(
     const AccountMetadata& account_metadata) {
   scoped_ptr<AppList> resource(new AppList);
 
   const ScopedVector<InstalledApp>& installed_apps =
@@ skipping 37 matching lines @@
   converter->RegisterBoolField(kIsRoot, &ParentReference::is_root_);
 }
 
 // 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>(NULL);
+    return scoped_ptr<ParentReference>();
   }
   return reference.Pass();
 }
 
 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 65 matching lines @@
       kOpenWithLinks,
       &FileResource::open_with_links_,
       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>(NULL);
+    return scoped_ptr<FileResource>();
   }
   return resource.Pass();
 }
 
 bool FileResource::IsDirectory() const {
   return mime_type_ == kDriveFolderMimeType;
 }
 
 DriveEntryKind FileResource::GetKind() const {
   if (mime_type() == kGoogleDocumentMimeType)
@@ skipping 44 matching lines @@
 // 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());
   if (!HasFileListKind(value) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid FileList JSON!";
-    return scoped_ptr<FileList>(NULL);
+    return scoped_ptr<FileList>();
   }
   return resource.Pass();
 }
 
 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 17 matching lines @@
   converter->RegisterBoolField(kDeleted, &ChangeResource::deleted_);
   converter->RegisterNestedField(kFile, &ChangeResource::file_);
 }
 
 // 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>(NULL);
+    return scoped_ptr<ChangeResource>();
   }
   return resource.Pass();
 }
 
 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 25 matching lines @@
 // 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());
   if (!HasChangeListKind(value) || !resource->Parse(value)) {
     LOG(ERROR) << "Unable to create: Invalid ChangeList JSON!";
-    return scoped_ptr<ChangeList>(NULL);
+    return scoped_ptr<ChangeList>();
   }
   return resource.Pass();
 }
 
 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;
   }
@@ skipping 21 matching lines @@
   converter->RegisterBoolField(kLabelTrashed, &FileLabels::trashed_);
   converter->RegisterBoolField(kLabelRestricted, &FileLabels::restricted_);
   converter->RegisterBoolField(kLabelViewed, &FileLabels::viewed_);
 }
 
 // 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>(NULL);
+    return scoped_ptr<FileLabels>();
   }
   return resource.Pass();
 }
 
 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;
 }
 
 }  // namespace google_apis