[SyncFS] Use nullptr for scoped_ptr initialization

chrome/browser/sync_file_system/drive_backend/sync_task_manager.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 "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 273 matching lines @@
     if (!foreground_task_token) {
       PushPendingTask(
           base::Bind(&SyncTaskManager::UpdateTaskBlockerBody,
                      AsWeakPtr(),
                      base::Passed(&foreground_task_token),
                      base::Passed(&background_task_token),
                      base::Passed(&task_log),
                      base::Passed(&task_blocker),
                      continuation),
           PRIORITY_HIGH);
-      MaybeStartNextForegroundTask(scoped_ptr<SyncTaskToken>());
+      MaybeStartNextForegroundTask(nullptr);
       return;
     }
   }
 
   // Check if the task can run as a background task now.
   // If there are too many task running or any other task blocks current
   // task, wait for any other task to finish.
   bool task_number_limit_exceeded =
       !background_task_token &&
       running_background_tasks_.size() >= maximum_background_task_;
@@ skipping 25 matching lines @@
         SyncTaskToken::CreateForBackgroundTask(AsWeakPtr(),
                                                task_runner_.get(),
                                                task_token_seq_++,
                                                task_blocker.Pass());
     background_task_token->UpdateTask(from_here, callback);
     running_background_tasks_.set(background_task_token->token_id(),
                                   running_foreground_task_.Pass());
   }
 
   token_ = foreground_task_token.Pass();
-  MaybeStartNextForegroundTask(scoped_ptr<SyncTaskToken>());
+  MaybeStartNextForegroundTask(nullptr);
   background_task_token->SetTaskLog(task_log.Pass());
   continuation.Run(background_task_token.Pass());
 }
 
 scoped_ptr<SyncTaskToken> SyncTaskManager::GetToken(
     const tracked_objects::Location& from_here,
     const SyncStatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!token_)
-    return scoped_ptr<SyncTaskToken>();
+    return nullptr;
   token_->UpdateTask(from_here, callback);
   return token_.Pass();
 }
 
 void SyncTaskManager::PushPendingTask(
     const base::Closure& closure, Priority priority) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   pending_tasks_.push(PendingTask(closure, priority, pending_task_seq_++));
 }
@@ skipping 32 matching lines @@
     closure.Run();
     return;
   }
 
   if (client_)
     client_->MaybeScheduleNextTask();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system