Remove base::ScopedPtrHashMap from chrome/browser/sync_file_system/drive_backend/

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 <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 183 matching lines @@
 bool SyncTaskManager::IsRunningTask(int64_t token_id) const {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   // If the client is gone, all task should be aborted.
   if (!client_)
     return false;
 
   if (token_id == SyncTaskToken::kForegroundTaskTokenID)
     return true;
 
-  return ContainsKey(running_background_tasks_, token_id);
+  return running_background_tasks_.find(token_id) !=
+         running_background_tasks_.end();
 }
 
 void SyncTaskManager::DetachFromSequence() {
   sequence_checker_.DetachFromSequence();
 }
 
 bool SyncTaskManager::ShouldTrackTaskToken() const {
   return !worker_pool_ || !worker_pool_->IsShutdownInProgress();
 }
 
@@ skipping 18 matching lines @@
     }
   }
 
   std::unique_ptr<SyncTask> task;
   SyncStatusCallback callback = token->callback();
   token->clear_callback();
   if (token->token_id() == SyncTaskToken::kForegroundTaskTokenID) {
     token_ = std::move(token);
     task = std::move(running_foreground_task_);
   } else {
-    task = running_background_tasks_.take_and_erase(token->token_id());
+    task = std::move(running_background_tasks_[token->token_id()]);
+    running_background_tasks_.erase(token->token_id());
   }
 
   // Acquire the token to prevent a new task to jump into the queue.
   token = std::move(token_);
 
   bool task_used_network = false;
   if (task)
     task_used_network = task->used_network();
 
   if (client_)
@@ skipping 82 matching lines @@
     background_task_token->set_task_blocker(std::move(task_blocker));
   } else {
     tracked_objects::Location from_here = foreground_task_token->location();
     SyncStatusCallback callback = foreground_task_token->callback();
     foreground_task_token->clear_callback();
 
     background_task_token = SyncTaskToken::CreateForBackgroundTask(
         weak_ptr_factory_.GetWeakPtr(), task_runner_.get(), task_token_seq_++,
         std::move(task_blocker));
     background_task_token->UpdateTask(from_here, callback);
-    running_background_tasks_.set(background_task_token->token_id(),
-                                  std::move(running_foreground_task_));
+    running_background_tasks_[background_task_token->token_id()] =
+        std::move(running_foreground_task_);
   }
 
   token_ = std::move(foreground_task_token);
   MaybeStartNextForegroundTask(nullptr);
   background_task_token->SetTaskLog(std::move(task_log));
   continuation.Run(std::move(background_task_token));
 }
 
 std::unique_ptr<SyncTaskToken> SyncTaskManager::GetToken(
     const tracked_objects::Location& from_here,
@@ skipping 47 matching lines @@
     closure.Run();
     return;
   }
 
   if (client_)
     client_->MaybeScheduleNextTask();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system