Remove most ScopedVector usage from c/b/extensions.

chrome/browser/extensions/api/tab_capture/tab_capture_registry.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/extensions/api/tab_capture/tab_capture_registry.h"
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
@@ skipping 244 matching lines @@
 TabCaptureRegistry::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void TabCaptureRegistry::GetCapturedTabs(
     const std::string& extension_id,
     base::ListValue* list_of_capture_info) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(list_of_capture_info);
   list_of_capture_info->Clear();
-  for (const LiveRequest* request : requests_) {
+  for (const std::unique_ptr<LiveRequest>& request : requests_) {
     if (request->is_anonymous() || !request->is_verified() ||
         request->extension_id() != extension_id)
       continue;
     tab_capture::CaptureInfo info;
     request->GetCaptureInfo(&info);
     list_of_capture_info->Append(info.ToValue());
   }
 }
 
 void TabCaptureRegistry::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   // Cleanup all the requested media streams for this extension.
-  for (ScopedVector<LiveRequest>::iterator it = requests_.begin();
+  for (std::vector<std::unique_ptr<LiveRequest>>::iterator it =
+           requests_.begin();
        it != requests_.end();) {
     if ((*it)->extension_id() == extension->id()) {
       it = requests_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 bool TabCaptureRegistry::AddRequest(content::WebContents* target_contents,
                                     const std::string& extension_id,
                                     bool is_anonymous) {
   LiveRequest* const request = FindRequest(target_contents);
 
   // Currently, we do not allow multiple active captures for same tab.
   if (request != NULL) {
     if (request->capture_state() == tab_capture::TAB_CAPTURE_STATE_PENDING ||
         request->capture_state() == tab_capture::TAB_CAPTURE_STATE_ACTIVE) {
       return false;
     } else {
       // Delete the request before creating its replacement (below).
       KillRequest(request);
     }
   }
 
-  requests_.push_back(
-      new LiveRequest(target_contents, extension_id, is_anonymous, this));
+  requests_.push_back(base::MakeUnique<LiveRequest>(
+      target_contents, extension_id, is_anonymous, this));
   return true;
 }
 
 bool TabCaptureRegistry::VerifyRequest(
     int render_process_id,
     int render_frame_id,
     const std::string& extension_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   LiveRequest* const request = FindRequest(
@@ skipping 101 matching lines @@
   std::unique_ptr<Event> event(
       new Event(events::TAB_CAPTURE_ON_STATUS_CHANGED,
                 tab_capture::OnStatusChanged::kEventName, std::move(args)));
   event->restrict_to_browser_context = browser_context_;
 
   router->DispatchEventToExtension(request->extension_id(), std::move(event));
 }
 
 TabCaptureRegistry::LiveRequest* TabCaptureRegistry::FindRequest(
     const content::WebContents* target_contents) const {
-  for (ScopedVector<LiveRequest>::const_iterator it = requests_.begin();
-       it != requests_.end(); ++it) {
-    if ((*it)->web_contents() == target_contents)
-      return *it;
+  for (const auto& request : requests_) {
+    if (request->web_contents() == target_contents)
+      return request.get();
   }
-  return NULL;
+  return nullptr;
 }
 
 TabCaptureRegistry::LiveRequest* TabCaptureRegistry::FindRequest(
     int original_target_render_process_id,
     int original_target_render_frame_id) const {
-  for (ScopedVector<LiveRequest>::const_iterator it = requests_.begin();
-       it != requests_.end(); ++it) {
-    if ((*it)->WasOriginallyTargettingRenderFrameID(
+  for (const std::unique_ptr<LiveRequest>& request : requests_) {
+    if (request->WasOriginallyTargettingRenderFrameID(
             original_target_render_process_id,
-            original_target_render_frame_id))
-      return *it;
+            original_target_render_frame_id)) {
+      return request.get();
+    }
   }
-  return NULL;
+  return nullptr;
 }
 
 void TabCaptureRegistry::KillRequest(LiveRequest* request) {
-  for (ScopedVector<LiveRequest>::iterator it = requests_.begin();
+  for (std::vector<std::unique_ptr<LiveRequest>>::iterator it =
+           requests_.begin();
        it != requests_.end(); ++it) {
-    if ((*it) == request) {
+    if (it->get() == request) {
       requests_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
 }  // namespace extensions