Remove ScopedVector from URLRequestInterceptorScopedVector.

content/public/browser/browser_context.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_BROWSER_CONTEXT_H_
 #define CONTENT_PUBLIC_BROWSER_BROWSER_CONTEXT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
+#include <vector>
 
 #include "base/callback_forward.h"
 #include "base/containers/hash_tables.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_vector.h"
 #include "base/supports_user_data.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/zoom_level_delegate.h"
 #include "content/public/common/push_event_payload.h"
 #include "content/public/common/push_messaging_status.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job_factory.h"
 
 class GURL;
 
@@ skipping 28 matching lines @@
 class PermissionManager;
 class PushMessagingService;
 class ResourceContext;
 class ServiceManagerConnection;
 class SiteInstance;
 class StoragePartition;
 class SSLHostStateDelegate;
 
 // A mapping from the scheme name to the protocol handler that services its
 // content.
-typedef std::map<
-  std::string, linked_ptr<net::URLRequestJobFactory::ProtocolHandler> >
-    ProtocolHandlerMap;
+using ProtocolHandlerMap =
+    std::map<std::string,
+             linked_ptr<net::URLRequestJobFactory::ProtocolHandler>>;
 
-// A scoped vector of protocol interceptors.
-typedef ScopedVector<net::URLRequestInterceptor>
-    URLRequestInterceptorScopedVector;
+// A owning vector of protocol interceptors.
+using URLRequestInterceptorScopedVector =
+    std::vector<std::unique_ptr<net::URLRequestInterceptor>>;
 
 // This class holds the context needed for a browsing session.
 // It lives on the UI thread. All these methods must only be called on the UI
 // thread.
 class CONTENT_EXPORT BrowserContext : public base::SupportsUserData {
  public:
   static DownloadManager* GetDownloadManager(BrowserContext* browser_context);
 
   // Returns BrowserContext specific external mount points. It may return
   // nullptr if the context doesn't have any BrowserContext specific external
   // mount points. Currenty, non-nullptr value is returned only on ChromeOS.
   static storage::ExternalMountPoints* GetMountPoints(BrowserContext* context);
 
   static content::StoragePartition* GetStoragePartition(
       BrowserContext* browser_context, SiteInstance* site_instance);
   static content::StoragePartition* GetStoragePartitionForSite(
       BrowserContext* browser_context, const GURL& site);
-  typedef base::Callback<void(StoragePartition*)> StoragePartitionCallback;
+  using StoragePartitionCallback = base::Callback<void(StoragePartition*)>;
   static void ForEachStoragePartition(
       BrowserContext* browser_context,
       const StoragePartitionCallback& callback);
   static void AsyncObliterateStoragePartition(
       BrowserContext* browser_context,
       const GURL& site,
       const base::Closure& on_gc_required);
 
   // This function clears the contents of |active_paths| but does not take
   // ownership of the pointer.
   static void GarbageCollectStoragePartitions(
       BrowserContext* browser_context,
       std::unique_ptr<base::hash_set<base::FilePath>> active_paths,
       const base::Closure& done);
 
   static content::StoragePartition* GetDefaultStoragePartition(
       BrowserContext* browser_context);
 
-  typedef base::Callback<void(std::unique_ptr<BlobHandle>)> BlobCallback;
+  using BlobCallback = base::Callback<void(std::unique_ptr<BlobHandle>)>;
 
   // |callback| returns a nullptr scoped_ptr on failure.
   static void CreateMemoryBackedBlob(BrowserContext* browser_context,
                                      const char* data, size_t length,
                                      const BlobCallback& callback);
 
   // |callback| returns a nullptr scoped_ptr on failure.
   static void CreateFileBackedBlob(BrowserContext* browser_context,
                                    const base::FilePath& path,
                                    int64_t offset,
@@ skipping 122 matching lines @@
   // called only once per partition_path.
   virtual net::URLRequestContextGetter*
       CreateMediaRequestContextForStoragePartition(
           const base::FilePath& partition_path,
           bool in_memory) = 0;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_BROWSER_CONTEXT_H_