diff --git a/base/trace_event/memory_usage_estimator.h b/base/trace_event/memory_usage_estimator.h
index 90c94aba931f44..4e4f8dc32eece1 100644
--- a/base/trace_event/memory_usage_estimator.h
+++ b/base/trace_event/memory_usage_estimator.h
@@ -22,9 +22,11 @@
 #include <vector>
 
 #include "base/base_export.h"
+#include "base/containers/circular_deque.h"
 #include "base/containers/flat_map.h"
 #include "base/containers/flat_set.h"
 #include "base/containers/linked_list.h"
+#include "base/containers/queue.h"
 #include "base/strings/string16.h"
 
 // Composable memory usage estimators.
@@ -152,6 +154,9 @@ size_t EstimateMemoryUsage(const std::priority_queue<T, C>& queue);
 template <class T, class C>
 size_t EstimateMemoryUsage(const std::stack<T, C>& stack);
 
+template <class T>
+size_t EstimateMemoryUsage(const base::circular_deque<T>& deque);
+
 template <class T, class C>
 size_t EstimateMemoryUsage(const base::flat_set<T, C>& set);
 
@@ -550,6 +555,13 @@ size_t EstimateMemoryUsage(const std::stack<T, C>& stack) {
   return EstimateMemoryUsage(internal::GetUnderlyingContainer(stack));
 }
 
+// base::circular_deque
+
+template <class T>
+size_t EstimateMemoryUsage(const base::circular_deque<T>& deque) {
+  return sizeof(T) * deque.capacity() + EstimateIterableMemoryUsage(deque);
+}
+
 // Flat containers
 
 template <class T, class C>
diff --git a/chrome/browser/ui/cocoa/content_settings/cookies_tree_controller_bridge.mm b/chrome/browser/ui/cocoa/content_settings/cookies_tree_controller_bridge.mm
index 88df20be7dad61..0a0ecc7680dbf7 100644
--- a/chrome/browser/ui/cocoa/content_settings/cookies_tree_controller_bridge.mm
+++ b/chrome/browser/ui/cocoa/content_settings/cookies_tree_controller_bridge.mm
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <queue>
+
 #import "chrome/browser/ui/cocoa/content_settings/cookies_tree_controller_bridge.h"
 
 CookiesTreeControllerBridge::CookiesTreeControllerBridge(
diff --git a/net/cookies/cookie_monster.cc b/net/cookies/cookie_monster.cc
index f0fee4be810b59..05c3667d5baa2e 100644
--- a/net/cookies/cookie_monster.cc
+++ b/net/cookies/cookie_monster.cc
@@ -2001,14 +2001,15 @@ void CookieMonster::DoCookieCallbackForURL(base::OnceClosure callback,
     // Checks if the domain key has been loaded.
     std::string key(cookie_util::GetEffectiveDomain(url.scheme(), url.host()));
     if (keys_loaded_.find(key) == keys_loaded_.end()) {
-      std::map<std::string, std::deque<base::OnceClosure>>::iterator it =
-          tasks_pending_for_key_.find(key);
+      std::map<std::string, base::circular_deque<base::OnceClosure>>::iterator
+          it = tasks_pending_for_key_.find(key);
       if (it == tasks_pending_for_key_.end()) {
         store_->LoadCookiesForKey(
             key, base::Bind(&CookieMonster::OnKeyLoaded,
                             weak_ptr_factory_.GetWeakPtr(), key));
         it = tasks_pending_for_key_
-                 .insert(std::make_pair(key, std::deque<base::OnceClosure>()))
+                 .insert(std::make_pair(
+                     key, base::circular_deque<base::OnceClosure>()))
                  .first;
       }
       it->second.push_back(std::move(callback));
diff --git a/net/cookies/cookie_monster.h b/net/cookies/cookie_monster.h
index cf51b6c4165eb6..99da40b030e596 100644
--- a/net/cookies/cookie_monster.h
+++ b/net/cookies/cookie_monster.h
@@ -10,16 +10,15 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <deque>
 #include <map>
 #include <memory>
-#include <queue>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback_forward.h"
+#include "base/containers/circular_deque.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -685,11 +684,12 @@ class NET_EXPORT CookieMonster : public CookieStore {
   // Map of domain keys to their associated task queues. These tasks are blocked
   // until all cookies for the associated domain key eTLD+1 are loaded from the
   // backend store.
-  std::map<std::string, std::deque<base::OnceClosure>> tasks_pending_for_key_;
+  std::map<std::string, base::circular_deque<base::OnceClosure>>
+      tasks_pending_for_key_;
 
   // Queues tasks that are blocked until all cookies are loaded from the backend
   // store.
-  std::deque<base::OnceClosure> tasks_pending_;
+  base::circular_deque<base::OnceClosure> tasks_pending_;
 
   // Once a global cookie task has been seen, all per-key tasks must be put in
   // |tasks_pending_| instead of |tasks_pending_for_key_| to ensure a reasonable
diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc
index c921d50643bcb3..0b1b2b852a1b78 100644
--- a/net/cookies/cookie_monster_unittest.cc
+++ b/net/cookies/cookie_monster_unittest.cc
@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "base/bind.h"
+#include "base/containers/queue.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ -1015,7 +1016,7 @@ class DeferredCookieTaskTest : public CookieMonsterTest {
   CookieMonster::PersistentCookieStore::LoadedCallback loaded_callback_;
   // Stores the callback passed from the CookieMonster to the
   // PersistentCookieStore::LoadCookiesForKey
-  std::queue<CookieMonster::PersistentCookieStore::LoadedCallback>
+  base::queue<CookieMonster::PersistentCookieStore::LoadedCallback>
       loaded_for_key_callbacks_;
   // base::RunLoop used to wait for PersistentCookieStore::Load to be called.
   base::RunLoop load_run_loop_;
diff --git a/net/disk_cache/simple/simple_entry_impl.h b/net/disk_cache/simple/simple_entry_impl.h
index b373c7e4baeb83..e3ebe51a6d0bcf 100644
--- a/net/disk_cache/simple/simple_entry_impl.h
+++ b/net/disk_cache/simple/simple_entry_impl.h
@@ -8,9 +8,9 @@
 #include <stdint.h>
 
 #include <memory>
-#include <queue>
 #include <string>
 
+#include "base/containers/queue.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/thread_checker.h"
@@ -389,7 +389,7 @@ class NET_EXPORT_PRIVATE SimpleEntryImpl : public Entry,
   // would leak the SimpleSynchronousEntry.
   SimpleSynchronousEntry* synchronous_entry_;
 
-  std::queue<SimpleEntryOperation> pending_operations_;
+  base::queue<SimpleEntryOperation> pending_operations_;
 
   net::NetLogWithSource net_log_;
 
diff --git a/net/dns/dns_transaction.cc b/net/dns/dns_transaction.cc
index 55906dd816147b..11ea8202c6253a 100644
--- a/net/dns/dns_transaction.cc
+++ b/net/dns/dns_transaction.cc
@@ -4,7 +4,6 @@
 
 #include "net/dns/dns_transaction.h"
 
-#include <deque>
 #include <memory>
 #include <string>
 #include <utility>
@@ -12,6 +11,7 @@
 
 #include "base/big_endian.h"
 #include "base/bind.h"
+#include "base/containers/circular_deque.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ -950,7 +950,7 @@ class DnsTransactionImpl : public DnsTransaction,
   NetLogWithSource net_log_;
 
   // Search list of fully-qualified DNS names to query next (in DNS format).
-  std::deque<std::string> qnames_;
+  base::circular_deque<std::string> qnames_;
   size_t qnames_initial_size_;
 
   // List of attempts for the current name.
diff --git a/net/dns/dns_transaction_unittest.cc b/net/dns/dns_transaction_unittest.cc
index 8dce362362c992..0dc00f8b20035d 100644
--- a/net/dns/dns_transaction_unittest.cc
+++ b/net/dns/dns_transaction_unittest.cc
@@ -11,6 +11,7 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
@@ -476,7 +477,7 @@ class DnsTransactionTest : public testing::Test {
 
   std::vector<std::unique_ptr<DnsSocketData>> socket_data_;
 
-  std::deque<int> transaction_ids_;
+  base::circular_deque<int> transaction_ids_;
   std::unique_ptr<TestSocketFactory> socket_factory_;
   scoped_refptr<DnsSession> session_;
   std::unique_ptr<DnsTransactionFactory> transaction_factory_;
diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
index cc0fffe2cb35ef..be03fcfcf5aacf 100644
--- a/net/dns/host_resolver_impl.cc
+++ b/net/dns/host_resolver_impl.cc
@@ -30,6 +30,7 @@
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
+#include "base/containers/circular_deque.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
 #include "base/macros.h"
@@ -1885,7 +1886,7 @@ class HostResolverImpl::Job : public PrioritizedDispatcher::Job,
   std::unique_ptr<DnsTask> dns_task_;
 
   // All Requests waiting for the result of this Job. Some can be canceled.
-  std::deque<RequestImpl*> requests_;
+  base::circular_deque<RequestImpl*> requests_;
 
   // A handle used in |HostResolverImpl::dispatcher_|.
   PrioritizedDispatcher::Handle handle_;
diff --git a/net/dns/mdns_client_impl.cc b/net/dns/mdns_client_impl.cc
index a283d09c04ac4e..1b1d6deafb3915 100644
--- a/net/dns/mdns_client_impl.cc
+++ b/net/dns/mdns_client_impl.cc
@@ -5,7 +5,6 @@
 #include "net/dns/mdns_client_impl.h"
 
 #include <algorithm>
-#include <queue>
 #include <utility>
 
 #include "base/bind.h"
diff --git a/net/dns/mdns_client_impl.h b/net/dns/mdns_client_impl.h
index bd35e7cc601986..ad478981b125c2 100644
--- a/net/dns/mdns_client_impl.h
+++ b/net/dns/mdns_client_impl.h
@@ -9,12 +9,12 @@
 
 #include <map>
 #include <memory>
-#include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/cancelable_callback.h"
+#include "base/containers/queue.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
@@ -88,7 +88,7 @@ class NET_EXPORT_PRIVATE MDnsConnection {
     DnsResponse response_;
     IPEndPoint multicast_addr_;
     bool send_in_progress_;
-    std::queue<std::pair<scoped_refptr<IOBuffer>, unsigned> > send_queue_;
+    base::queue<std::pair<scoped_refptr<IOBuffer>, unsigned>> send_queue_;
 
     DISALLOW_COPY_AND_ASSIGN(SocketHandler);
   };
diff --git a/net/dns/mdns_client_unittest.cc b/net/dns/mdns_client_unittest.cc
index 2de0ce6a8bc428..1ac3dca974782d 100644
--- a/net/dns/mdns_client_unittest.cc
+++ b/net/dns/mdns_client_unittest.cc
@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include <memory>
-#include <queue>
 #include <vector>
 
 #include "base/location.h"
diff --git a/net/filter/mock_source_stream.h b/net/filter/mock_source_stream.h
index 4d854444c4233b..d329d96a297b29 100644
--- a/net/filter/mock_source_stream.h
+++ b/net/filter/mock_source_stream.h
@@ -5,9 +5,9 @@
 #ifndef NET_FILTER_MOCK_SOURCE_STREAM_H_
 #define NET_FILTER_MOCK_SOURCE_STREAM_H_
 
-#include <queue>
 #include <string>
 
+#include "base/containers/queue.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/completion_callback.h"
@@ -69,7 +69,7 @@ class MockSourceStream : public SourceStream {
   };
 
   bool read_one_byte_at_a_time_;
-  std::queue<QueuedResult> results_;
+  base::queue<QueuedResult> results_;
   bool awaiting_completion_;
   scoped_refptr<IOBuffer> dest_buffer_;
   CompletionCallback callback_;
diff --git a/net/ftp/ftp_ctrl_response_buffer.h b/net/ftp/ftp_ctrl_response_buffer.h
index e8683ec88ab293..d179b4da46085a 100644
--- a/net/ftp/ftp_ctrl_response_buffer.h
+++ b/net/ftp/ftp_ctrl_response_buffer.h
@@ -5,10 +5,10 @@
 #ifndef NET_FTP_FTP_CTRL_RESPONSE_BUFFER_H_
 #define NET_FTP_FTP_CTRL_RESPONSE_BUFFER_H_
 
-#include <queue>
 #include <string>
 #include <vector>
 
+#include "base/containers/queue.h"
 #include "base/macros.h"
 #include "net/base/net_export.h"
 #include "net/log/net_log_with_source.h"
@@ -76,7 +76,7 @@ class NET_EXPORT_PRIVATE FtpCtrlResponseBuffer {
   // We keep not-yet-parsed data in a string buffer.
   std::string buffer_;
 
-  std::queue<ParsedLine> lines_;
+  base::queue<ParsedLine> lines_;
 
   // True if we are in the middle of parsing a multi-line response.
   bool multiline_;
@@ -90,7 +90,7 @@ class NET_EXPORT_PRIVATE FtpCtrlResponseBuffer {
   FtpCtrlResponse response_buf_;
 
   // As we read full responses (possibly multiline), we add them to the queue.
-  std::queue<FtpCtrlResponse> responses_;
+  base::queue<FtpCtrlResponse> responses_;
 
   NetLogWithSource net_log_;
 
diff --git a/net/ftp/ftp_network_transaction_unittest.cc b/net/ftp/ftp_network_transaction_unittest.cc
index 3b04c6e401f90a..6d6e9100efc5f1 100644
--- a/net/ftp/ftp_network_transaction_unittest.cc
+++ b/net/ftp/ftp_network_transaction_unittest.cc
@@ -4,8 +4,7 @@
 
 #include "net/ftp/ftp_network_transaction.h"
 
-#include <deque>
-
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ -217,7 +216,7 @@ class FtpSocketDataProvider : public SocketDataProvider {
 
  private:
   // List of reads to be consumed.
-  std::deque<MockRead> reads_;
+  base::circular_deque<MockRead> reads_;
 
   // Max number of bytes we will read at a time. 0 means no limit.
   int short_read_limit_;
diff --git a/net/http/http_server_properties_impl.h b/net/http/http_server_properties_impl.h
index 6bde8224c9f13f..aa6a86dc756d97 100644
--- a/net/http/http_server_properties_impl.h
+++ b/net/http/http_server_properties_impl.h
@@ -8,7 +8,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <deque>
 #include <map>
 #include <set>
 #include <string>
diff --git a/net/http2/hpack/decoder/hpack_decoder_tables.h b/net/http2/hpack/decoder/hpack_decoder_tables.h
index 1ac5bdee679380..6a351168c2bad5 100644
--- a/net/http2/hpack/decoder/hpack_decoder_tables.h
+++ b/net/http2/hpack/decoder/hpack_decoder_tables.h
@@ -18,9 +18,9 @@
 
 #include <stddef.h>
 
-#include <deque>
 #include <vector>
 
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "net/http2/hpack/hpack_string.h"
 #include "net/http2/http2_constants.h"
@@ -128,7 +128,7 @@ class HTTP2_EXPORT_PRIVATE HpackDecoderDynamicTable {
   // Removes the oldest dynamic table entry.
   void RemoveLastEntry();
 
-  std::deque<HpackDecoderTableEntry> table_;
+  base::circular_deque<HpackDecoderTableEntry> table_;
 
   // The last received DynamicTableSizeUpdate value, initialized to
   // SETTINGS_HEADER_TABLE_SIZE.
diff --git a/net/log/file_net_log_observer.cc b/net/log/file_net_log_observer.cc
index d7ad9102de31f0..695a6f1ae2c483 100644
--- a/net/log/file_net_log_observer.cc
+++ b/net/log/file_net_log_observer.cc
@@ -6,11 +6,11 @@
 
 #include <algorithm>
 #include <memory>
-#include <queue>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/containers/queue.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ -100,7 +100,7 @@ void AppendToFileThenDelete(const base::FilePath& source_path,
 namespace net {
 
 // Used to store events to be written to file.
-using EventQueue = std::queue<std::unique_ptr<std::string>>;
+using EventQueue = base::queue<std::unique_ptr<std::string>>;
 
 // WriteQueue receives events from FileNetLogObserver on the main thread and
 // holds them in a queue until they are drained from the queue and written to
diff --git a/net/nqe/observation_buffer.h b/net/nqe/observation_buffer.h
index b293781fc709b1..d9a4bbe5152b4d 100644
--- a/net/nqe/observation_buffer.h
+++ b/net/nqe/observation_buffer.h
@@ -7,12 +7,12 @@
 
 #include <stdint.h>
 
-#include <deque>
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
+#include "base/containers/circular_deque.h"
 #include "base/optional.h"
 #include "base/time/tick_clock.h"
 #include "net/base/net_export.h"
@@ -115,7 +115,7 @@ class NET_EXPORT_PRIVATE ObservationBuffer {
 
   // Holds observations sorted by time, with the oldest observation at the
   // front of the queue.
-  std::deque<Observation> observations_;
+  base::circular_deque<Observation> observations_;
 
   // The factor by which the weight of an observation reduces every second.
   // For example, if an observation is 6 seconds old, its weight would be:
diff --git a/net/nqe/throughput_analyzer_unittest.cc b/net/nqe/throughput_analyzer_unittest.cc
index 58afa8386bdc57..44fd45d6876673 100644
--- a/net/nqe/throughput_analyzer_unittest.cc
+++ b/net/nqe/throughput_analyzer_unittest.cc
@@ -6,7 +6,6 @@
 
 #include <stdint.h>
 
-#include <deque>
 #include <map>
 #include <memory>
 #include <string>
@@ -15,6 +14,7 @@
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/containers/circular_deque.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ -109,7 +109,7 @@ TEST(ThroughputAnalyzerTest, MaximumRequests) {
     throughput_analyzer.AddIPAddressResolution(&context);
 
     ASSERT_FALSE(throughput_analyzer.disable_throughput_measurements());
-    std::deque<std::unique_ptr<URLRequest>> requests;
+    base::circular_deque<std::unique_ptr<URLRequest>> requests;
 
     // Start more requests than the maximum number of requests that can be held
     // in the memory.
diff --git a/net/proxy/mojo_proxy_resolver_impl.h b/net/proxy/mojo_proxy_resolver_impl.h
index 7951b4ab87d911..a7982ddb8e9083 100644
--- a/net/proxy/mojo_proxy_resolver_impl.h
+++ b/net/proxy/mojo_proxy_resolver_impl.h
@@ -7,7 +7,6 @@
 
 #include <map>
 #include <memory>
-#include <queue>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
diff --git a/net/proxy/multi_threaded_proxy_resolver.cc b/net/proxy/multi_threaded_proxy_resolver.cc
index 407710f01b1a39..2939402f85ac62 100644
--- a/net/proxy/multi_threaded_proxy_resolver.cc
+++ b/net/proxy/multi_threaded_proxy_resolver.cc
@@ -4,12 +4,12 @@
 
 #include "net/proxy/multi_threaded_proxy_resolver.h"
 
-#include <deque>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/containers/circular_deque.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
@@ -126,8 +126,8 @@ class MultiThreadedProxyResolver : public ProxyResolver,
   class RequestImpl;
   // FIFO queue of pending jobs waiting to be started.
   // TODO(eroman): Make this priority queue.
-  typedef std::deque<scoped_refptr<Job>> PendingJobsQueue;
-  typedef std::vector<scoped_refptr<Executor>> ExecutorList;
+  using PendingJobsQueue = base::circular_deque<scoped_refptr<Job>>;
+  using ExecutorList = std::vector<scoped_refptr<Executor>>;
 
   // Returns an idle worker thread which is ready to receive GetProxyForURL()
   // requests. If all threads are occupied, returns NULL.
diff --git a/net/proxy/proxy_resolver_factory_mojo_unittest.cc b/net/proxy/proxy_resolver_factory_mojo_unittest.cc
index c5924691ba7f34..a038a012d24ad2 100644
--- a/net/proxy/proxy_resolver_factory_mojo_unittest.cc
+++ b/net/proxy/proxy_resolver_factory_mojo_unittest.cc
@@ -7,12 +7,12 @@
 #include <list>
 #include <map>
 #include <memory>
-#include <queue>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
+#include "base/containers/queue.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ -199,7 +199,7 @@ class MockMojoProxyResolver : public interfaces::ProxyResolver {
 
   std::string pac_script_data_;
 
-  std::queue<GetProxyForUrlAction> get_proxy_actions_;
+  base::queue<GetProxyForUrlAction> get_proxy_actions_;
 
   base::Closure quit_closure_;
 
@@ -355,7 +355,7 @@ class MockMojoProxyResolverFactory : public interfaces::ProxyResolverFactory {
   void WakeWaiter();
 
   MockMojoProxyResolver* resolver_;
-  std::queue<CreateProxyResolverAction> create_resolver_actions_;
+  base::queue<CreateProxyResolverAction> create_resolver_actions_;
 
   base::Closure quit_closure_;
 
diff --git a/net/quic/chromium/mock_crypto_client_stream_factory.h b/net/quic/chromium/mock_crypto_client_stream_factory.h
index c61ea05c964df5..73cf808d2f20b8 100644
--- a/net/quic/chromium/mock_crypto_client_stream_factory.h
+++ b/net/quic/chromium/mock_crypto_client_stream_factory.h
@@ -5,9 +5,9 @@
 #ifndef NET_QUIC_CHROMIUM_MOCK_CRYPTO_CLIENT_STREAM_FACTORY_H_
 #define NET_QUIC_CHROMIUM_MOCK_CRYPTO_CLIENT_STREAM_FACTORY_H_
 
-#include <queue>
 #include <string>
 
+#include "base/containers/queue.h"
 #include "base/macros.h"
 #include "net/quic/chromium/crypto/proof_verifier_chromium.h"
 #include "net/quic/chromium/quic_crypto_client_stream_factory.h"
@@ -48,7 +48,7 @@ class MockCryptoClientStreamFactory : public QuicCryptoClientStreamFactory {
  private:
   MockCryptoClientStream::HandshakeMode handshake_mode_;
   MockCryptoClientStream* last_stream_;
-  std::queue<const ProofVerifyDetailsChromium*> proof_verify_details_queue_;
+  base::queue<const ProofVerifyDetailsChromium*> proof_verify_details_queue_;
   std::unique_ptr<QuicConfig> config_;
 
   DISALLOW_COPY_AND_ASSIGN(MockCryptoClientStreamFactory);
diff --git a/net/quic/chromium/quic_chromium_client_stream.h b/net/quic/chromium/quic_chromium_client_stream.h
index 6495f08cec74d5..1ccfc981fb083c 100644
--- a/net/quic/chromium/quic_chromium_client_stream.h
+++ b/net/quic/chromium/quic_chromium_client_stream.h
@@ -9,10 +9,10 @@
 
 #include <stddef.h>
 
-#include <deque>
 #include <vector>
 
 #include "base/callback_forward.h"
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_export.h"
diff --git a/net/quic/chromium/quic_stream_factory.h b/net/quic/chromium/quic_stream_factory.h
index 378d15a6bd4149..d20818aaf8f956 100644
--- a/net/quic/chromium/quic_stream_factory.h
+++ b/net/quic/chromium/quic_stream_factory.h
@@ -8,7 +8,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <deque>
 #include <list>
 #include <map>
 #include <set>
diff --git a/net/server/http_connection.h b/net/server/http_connection.h
index e708d3584fd56f..56a27f0b8261d6 100644
--- a/net/server/http_connection.h
+++ b/net/server/http_connection.h
@@ -6,9 +6,9 @@
 #define NET_SERVER_HTTP_CONNECTION_H_
 
 #include <memory>
-#include <queue>
 #include <string>
 
+#include "base/containers/queue.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/io_buffer.h"
@@ -103,7 +103,7 @@ class HttpConnection {
    private:
     ~QueuedWriteIOBuffer() override;
 
-    std::queue<std::string> pending_data_;
+    base::queue<std::string> pending_data_;
     int total_size_;
     int max_buffer_size_;
 
diff --git a/net/socket/client_socket_pool.h b/net/socket/client_socket_pool.h
index fb876a84ccd1cd..77fe4c2b21dbe9 100644
--- a/net/socket/client_socket_pool.h
+++ b/net/socket/client_socket_pool.h
@@ -5,7 +5,6 @@
 #ifndef NET_SOCKET_CLIENT_SOCKET_POOL_H_
 #define NET_SOCKET_CLIENT_SOCKET_POOL_H_
 
-#include <deque>
 #include <memory>
 #include <string>
 
diff --git a/net/socket/client_socket_pool_base.h b/net/socket/client_socket_pool_base.h
index 9abb6d1691f2ad..f5073c9c5b51d7 100644
--- a/net/socket/client_socket_pool_base.h
+++ b/net/socket/client_socket_pool_base.h
@@ -26,7 +26,6 @@
 #include <stdint.h>
 
 #include <cstddef>
-#include <deque>
 #include <list>
 #include <map>
 #include <memory>
diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h
index d6b9c99b196dab..3b4a860d86bb26 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -9,7 +9,6 @@
 #include <stdint.h>
 
 #include <cstring>
-#include <deque>
 #include <memory>
 #include <string>
 #include <vector>
diff --git a/net/socket/ssl_server_socket_unittest.cc b/net/socket/ssl_server_socket_unittest.cc
index 7a518cc1bba69f..d4930798683c09 100644
--- a/net/socket/ssl_server_socket_unittest.cc
+++ b/net/socket/ssl_server_socket_unittest.cc
@@ -17,11 +17,11 @@
 
 #include <stdint.h>
 #include <stdlib.h>
-#include <queue>
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
+#include "base/containers/queue.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
@@ -203,7 +203,7 @@ class FakeDataChannel {
 
   CompletionCallback write_callback_;
 
-  std::queue<scoped_refptr<DrainableIOBuffer> > data_;
+  base::queue<scoped_refptr<DrainableIOBuffer>> data_;
 
   // True if Close() has been called.
   bool closed_;
diff --git a/net/socket/transport_client_socket_pool_test_util.h b/net/socket/transport_client_socket_pool_test_util.h
index a15b400ee442a2..e7c9e3eee9db31 100644
--- a/net/socket/transport_client_socket_pool_test_util.h
+++ b/net/socket/transport_client_socket_pool_test_util.h
@@ -10,10 +10,10 @@
 #define NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_TEST_UTIL_H_
 
 #include <memory>
-#include <queue>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/containers/queue.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "net/base/address_list.h"
@@ -122,7 +122,7 @@ class MockTransportClientSocketFactory : public ClientSocketFactory {
   int client_socket_index_;
   int client_socket_index_max_;
   base::TimeDelta delay_;
-  std::queue<base::Closure> triggerable_sockets_;
+  base::queue<base::Closure> triggerable_sockets_;
   base::Closure run_loop_quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTransportClientSocketFactory);
diff --git a/net/socket/udp_socket_unittest.cc b/net/socket/udp_socket_unittest.cc
index 17782f7000820d..d49d110dee845b 100644
--- a/net/socket/udp_socket_unittest.cc
+++ b/net/socket/udp_socket_unittest.cc
@@ -5,6 +5,7 @@
 #include "net/socket/udp_socket.h"
 
 #include "base/bind.h"
+#include "base/containers/circular_deque.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ -362,7 +363,8 @@ static const int kBindRetries = 10;
 
 class TestPrng {
  public:
-  explicit TestPrng(const std::deque<int>& numbers) : numbers_(numbers) {}
+  explicit TestPrng(const base::circular_deque<int>& numbers)
+      : numbers_(numbers) {}
   int GetNext(int /* min */, int /* max */) {
     DCHECK(!numbers_.empty());
     int rv = numbers_.front();
@@ -370,7 +372,7 @@ class TestPrng {
     return rv;
   }
  private:
-  std::deque<int> numbers_;
+  base::circular_deque<int> numbers_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPrng);
 };
@@ -380,7 +382,7 @@ TEST_F(UDPSocketTest, ConnectRandomBind) {
   IPEndPoint peer_address(IPAddress::IPv4Localhost(), 53);
 
   // Create and connect sockets and save port numbers.
-  std::deque<int> used_ports;
+  base::circular_deque<int> used_ports;
   for (int i = 0; i < kBindRetries; ++i) {
     UDPClientSocket* socket = new UDPClientSocket(
         DatagramSocket::DEFAULT_BIND, RandIntCallback(), NULL, NetLogSource());
diff --git a/net/socket/websocket_transport_client_socket_pool_unittest.cc b/net/socket/websocket_transport_client_socket_pool_unittest.cc
index 231a8b6f7f3c7f..e8f78794a0e73e 100644
--- a/net/socket/websocket_transport_client_socket_pool_unittest.cc
+++ b/net/socket/websocket_transport_client_socket_pool_unittest.cc
@@ -4,7 +4,6 @@
 
 #include "net/socket/websocket_transport_client_socket_pool.h"
 
-#include <queue>
 #include <vector>
 
 #include "base/bind.h"
diff --git a/net/spdy/chromium/spdy_read_queue.h b/net/spdy/chromium/spdy_read_queue.h
index 3d6a73122e8e52..89c17da1b7fdf3 100644
--- a/net/spdy/chromium/spdy_read_queue.h
+++ b/net/spdy/chromium/spdy_read_queue.h
@@ -6,9 +6,9 @@
 #define NET_SPDY_CHROMIUM_SPDY_READ_QUEUE_H_
 
 #include <cstddef>
-#include <deque>
 #include <memory>
 
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "net/base/net_export.h"
 
@@ -42,7 +42,7 @@ class NET_EXPORT_PRIVATE SpdyReadQueue {
  private:
   // Class invariant:
   // |total_size_| is the sum of GetRemainingSize() of |queue_|'s elements.
-  std::deque<std::unique_ptr<SpdyBuffer>> queue_;
+  base::circular_deque<std::unique_ptr<SpdyBuffer>> queue_;
   size_t total_size_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyReadQueue);
diff --git a/net/spdy/chromium/spdy_session.cc b/net/spdy/chromium/spdy_session.cc
index bb1c0227e81763..e453ba22b577ec 100644
--- a/net/spdy/chromium/spdy_session.cc
+++ b/net/spdy/chromium/spdy_session.cc
@@ -3189,7 +3189,7 @@ void SpdySession::ResumeSendStalledStreams() {
   // have to worry about streams being closed, as well as ourselves
   // being closed.
 
-  std::deque<SpdyStream*> streams_to_requeue;
+  base::circular_deque<SpdyStream*> streams_to_requeue;
 
   while (!IsSendStalled()) {
     size_t old_size = 0;
@@ -3222,7 +3222,7 @@ void SpdySession::ResumeSendStalledStreams() {
 
 SpdyStreamId SpdySession::PopStreamToPossiblyResume() {
   for (int i = MAXIMUM_PRIORITY; i >= MINIMUM_PRIORITY; --i) {
-    std::deque<SpdyStreamId>* queue = &stream_send_unstall_queue_[i];
+    base::circular_deque<SpdyStreamId>* queue = &stream_send_unstall_queue_[i];
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
diff --git a/net/spdy/chromium/spdy_session.h b/net/spdy/chromium/spdy_session.h
index 7a3fad9732680d..202d2baa047265 100644
--- a/net/spdy/chromium/spdy_session.h
+++ b/net/spdy/chromium/spdy_session.h
@@ -8,12 +8,12 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <deque>
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
+#include "base/containers/circular_deque.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -613,10 +613,10 @@ class NET_EXPORT SpdySession : public BufferedSpdyFramerVisitorInterface,
   FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest,
                            ServerPushValidCrossOriginWithOpenSession);
 
-  typedef std::deque<base::WeakPtr<SpdyStreamRequest>>
-      PendingStreamRequestQueue;
-  typedef std::map<SpdyStreamId, SpdyStream*> ActiveStreamMap;
-  typedef std::set<SpdyStream*> CreatedStreamSet;
+  using PendingStreamRequestQueue =
+      base::circular_deque<base::WeakPtr<SpdyStreamRequest>>;
+  using ActiveStreamMap = std::map<SpdyStreamId, SpdyStream*>;
+  using CreatedStreamSet = std::set<SpdyStream*>;
 
   enum AvailabilityState {
     // The session is available in its socket pool and can be used
@@ -1158,7 +1158,7 @@ class NET_EXPORT SpdySession : public BufferedSpdyFramerVisitorInterface,
 
   // A queue of stream IDs that have been send-stalled at some point
   // in the past.
-  std::deque<SpdyStreamId> stream_send_unstall_queue_[NUM_PRIORITIES];
+  base::circular_deque<SpdyStreamId> stream_send_unstall_queue_[NUM_PRIORITIES];
 
   NetLogWithSource net_log_;
 
diff --git a/net/spdy/chromium/spdy_stream.h b/net/spdy/chromium/spdy_stream.h
index 9dcd13b7d1be9a..05babfb12d6ce9 100644
--- a/net/spdy/chromium/spdy_stream.h
+++ b/net/spdy/chromium/spdy_stream.h
@@ -8,7 +8,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <deque>
 #include <memory>
 #include <vector>
 
diff --git a/net/spdy/chromium/spdy_write_queue.cc b/net/spdy/chromium/spdy_write_queue.cc
index eb91b74fba9d4d..246c4d921a1951 100644
--- a/net/spdy/chromium/spdy_write_queue.cc
+++ b/net/spdy/chromium/spdy_write_queue.cc
@@ -8,6 +8,7 @@
 #include <utility>
 #include <vector>
 
+#include "base/containers/circular_deque.h"
 #include "base/logging.h"
 #include "net/spdy/chromium/spdy_buffer.h"
 #include "net/spdy/chromium/spdy_buffer_producer.h"
@@ -108,7 +109,7 @@ void SpdyWriteQueue::RemovePendingWritesForStream(
   std::vector<std::unique_ptr<SpdyBufferProducer>> erased_buffer_producers;
 
   // Do the actual deletion and removal, preserving FIFO-ness.
-  std::deque<PendingWrite>& queue = queue_[priority];
+  base::circular_deque<PendingWrite>& queue = queue_[priority];
   auto out_it = queue.begin();
   for (auto it = queue.begin(); it != queue.end(); ++it) {
     if (it->stream.get() == stream.get()) {
@@ -130,7 +131,7 @@ void SpdyWriteQueue::RemovePendingWritesForStreamsAfter(
 
   for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
     // Do the actual deletion and removal, preserving FIFO-ness.
-    std::deque<PendingWrite>& queue = queue_[i];
+    base::circular_deque<PendingWrite>& queue = queue_[i];
     auto out_it = queue.begin();
     for (auto it = queue.begin(); it != queue.end(); ++it) {
       if (it->stream.get() && (it->stream->stream_id() > last_good_stream_id ||
diff --git a/net/spdy/chromium/spdy_write_queue.h b/net/spdy/chromium/spdy_write_queue.h
index 77b77d075b92d4..23377e1cf830c0 100644
--- a/net/spdy/chromium/spdy_write_queue.h
+++ b/net/spdy/chromium/spdy_write_queue.h
@@ -5,9 +5,9 @@
 #ifndef NET_SPDY_CHROMIUM_SPDY_WRITE_QUEUE_H_
 #define NET_SPDY_CHROMIUM_SPDY_WRITE_QUEUE_H_
 
-#include <deque>
 #include <memory>
 
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/net_export.h"
@@ -88,7 +88,7 @@ class NET_EXPORT_PRIVATE SpdyWriteQueue {
   bool removing_writes_;
 
   // The actual write queue, binned by priority.
-  std::deque<PendingWrite> queue_[NUM_PRIORITIES];
+  base::circular_deque<PendingWrite> queue_[NUM_PRIORITIES];
 
   DISALLOW_COPY_AND_ASSIGN(SpdyWriteQueue);
 };
diff --git a/net/spdy/core/hpack/hpack_header_table.h b/net/spdy/core/hpack/hpack_header_table.h
index 6192305ead82d4..9cfe227505908e 100644
--- a/net/spdy/core/hpack/hpack_header_table.h
+++ b/net/spdy/core/hpack/hpack_header_table.h
@@ -54,10 +54,12 @@ class SPDY_EXPORT_PRIVATE HpackHeaderTable {
 
   // HpackHeaderTable takes advantage of the deque property that references
   // remain valid, so long as insertions & deletions are at the head & tail.
-  // If this changes (eg we start to drop entries from the middle of the table),
-  // this needs to be a std::list, in which case |*_index_| can be trivially
-  // extended to map to list iterators.
-  typedef std::deque<HpackEntry> EntryTable;
+  // This precludes the use of base::circular_deque.
+  //
+  // If this changes (we want to change to circular_deque or we start to drop
+  // entries from the middle of the table), this should to be a std::list, in
+  // which case |*_index_| can be trivially extended to map to list iterators.
+  using EntryTable = std::deque<HpackEntry>;
 
   struct SPDY_EXPORT_PRIVATE EntryHasher {
     size_t operator()(const HpackEntry* entry) const;
diff --git a/net/spdy/core/priority_write_scheduler.h b/net/spdy/core/priority_write_scheduler.h
index b4c54608d889a4..fa14d4d9f4648b 100644
--- a/net/spdy/core/priority_write_scheduler.h
+++ b/net/spdy/core/priority_write_scheduler.h
@@ -9,12 +9,12 @@
 #include <stdint.h>
 
 #include <algorithm>
-#include <deque>
 #include <tuple>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
+#include "base/containers/circular_deque.h"
 #include "base/logging.h"
 #include "net/spdy/core/spdy_bug_tracker.h"
 #include "net/spdy/core/spdy_protocol.h"
@@ -261,8 +261,8 @@ class PriorityWriteScheduler : public WriteScheduler<StreamIdType> {
     bool ready;
   };
 
-  // 0(1) size lookup, 0(1) insert at front or back.
-  typedef std::deque<StreamInfo*> ReadyList;
+  // 0(1) size lookup, Amortized 0(1) insert at front or back.
+  using ReadyList = base::circular_deque<StreamInfo*>;
 
   // State kept for each priority level.
   struct PriorityInfo {
diff --git a/net/url_request/sdch_dictionary_fetcher.cc b/net/url_request/sdch_dictionary_fetcher.cc
index c5879b9bc01cff..82ec8752e3655b 100644
--- a/net/url_request/sdch_dictionary_fetcher.cc
+++ b/net/url_request/sdch_dictionary_fetcher.cc
@@ -5,12 +5,12 @@
 #include "net/url_request/sdch_dictionary_fetcher.h"
 
 #include <stdint.h>
-#include <queue>
 #include <set>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/containers/queue.h"
 #include "base/macros.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/io_buffer.h"
@@ -75,7 +75,7 @@ class SdchDictionaryFetcher::UniqueFetchQueue {
   void Clear();
 
  private:
-  std::queue<FetchInfo> queue_;
+  base::queue<FetchInfo> queue_;
   std::set<GURL> ever_network_queued_;
 
   DISALLOW_COPY_AND_ASSIGN(UniqueFetchQueue);
diff --git a/net/url_request/url_request_throttler_entry.h b/net/url_request/url_request_throttler_entry.h
index d683a1e5589cd9..317537f90c9b31 100644
--- a/net/url_request/url_request_throttler_entry.h
+++ b/net/url_request/url_request_throttler_entry.h
@@ -7,9 +7,9 @@
 
 #include <stdint.h>
 
-#include <queue>
 #include <string>
 
+#include "base/containers/queue.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "net/base/backoff_entry.h"
@@ -132,7 +132,7 @@ class NET_EXPORT URLRequestThrottlerEntry
 
   // A list of the recent send events. We use them to decide whether there are
   // too many requests sent in sliding window.
-  std::queue<base::TimeTicks> send_log_;
+  base::queue<base::TimeTicks> send_log_;
 
   const base::TimeDelta sliding_window_period_;
   const int max_send_threshold_;
diff --git a/net/websockets/websocket_channel.cc b/net/websockets/websocket_channel.cc
index 5c4bf684ec3a76..658b8fd8184db3 100644
--- a/net/websockets/websocket_channel.cc
+++ b/net/websockets/websocket_channel.cc
@@ -8,12 +8,12 @@
 #include <stddef.h>
 
 #include <algorithm>
-#include <deque>
 #include <utility>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
+#include "base/containers/circular_deque.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -251,6 +251,55 @@ class WebSocketChannel::HandshakeNotificationSender
   std::unique_ptr<WebSocketHandshakeResponseInfo> handshake_response_info_;
 };
 
+class WebSocketChannel::PendingReceivedFrame {
+ public:
+  PendingReceivedFrame(bool final,
+                       WebSocketFrameHeader::OpCode opcode,
+                       scoped_refptr<IOBuffer> data,
+                       uint64_t offset,
+                       uint64_t size)
+      : final_(final),
+        opcode_(opcode),
+        data_(std::move(data)),
+        offset_(offset),
+        size_(size) {}
+  PendingReceivedFrame(const PendingReceivedFrame& other) = default;
+  ~PendingReceivedFrame() = default;
+
+  bool final() const { return final_; }
+  WebSocketFrameHeader::OpCode opcode() const { return opcode_; }
+
+  // ResetOpcode() to Continuation.
+  void ResetOpcode() {
+    DCHECK(WebSocketFrameHeader::IsKnownDataOpCode(opcode_));
+    opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
+  }
+  const scoped_refptr<IOBuffer>& data() const { return data_; }
+  uint64_t offset() const { return offset_; }
+  uint64_t size() const { return size_; }
+
+  // Increase |offset_| by |bytes|.
+  void DidConsume(uint64_t bytes) {
+    DCHECK_LE(offset_, size_);
+    DCHECK_LE(bytes, size_ - offset_);
+    offset_ += bytes;
+  }
+
+  // This object needs to be copyable and assignable, since it will be placed
+  // in a base::queue. The compiler-generated copy constructor and assignment
+  // operator will do the right thing.
+
+ private:
+  bool final_;
+  WebSocketFrameHeader::OpCode opcode_;
+  scoped_refptr<IOBuffer> data_;
+  // Where to start reading from data_. Everything prior to offset_ has
+  // already been sent to the browser.
+  uint64_t offset_;
+  // The size of data_.
+  uint64_t size_;
+};
+
 WebSocketChannel::HandshakeNotificationSender::HandshakeNotificationSender(
     WebSocketChannel* channel)
     : owner_(channel) {}
@@ -289,34 +338,6 @@ ChannelState WebSocketChannel::HandshakeNotificationSender::SendImmediately(
   return CHANNEL_ALIVE;
 }
 
-WebSocketChannel::PendingReceivedFrame::PendingReceivedFrame(
-    bool final,
-    WebSocketFrameHeader::OpCode opcode,
-    scoped_refptr<IOBuffer> data,
-    uint64_t offset,
-    uint64_t size)
-    : final_(final),
-      opcode_(opcode),
-      data_(std::move(data)),
-      offset_(offset),
-      size_(size) {}
-
-WebSocketChannel::PendingReceivedFrame::PendingReceivedFrame(
-    const PendingReceivedFrame& other) = default;
-
-WebSocketChannel::PendingReceivedFrame::~PendingReceivedFrame() {}
-
-void WebSocketChannel::PendingReceivedFrame::ResetOpcode() {
-  DCHECK(WebSocketFrameHeader::IsKnownDataOpCode(opcode_));
-  opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
-}
-
-void WebSocketChannel::PendingReceivedFrame::DidConsume(uint64_t bytes) {
-  DCHECK_LE(offset_, size_);
-  DCHECK_LE(bytes, size_ - offset_);
-  offset_ += bytes;
-}
-
 WebSocketChannel::WebSocketChannel(
     std::unique_ptr<WebSocketEventInterface> event_interface,
     URLRequestContext* url_request_context)
diff --git a/net/websockets/websocket_channel.h b/net/websockets/websocket_channel.h
index e763d15bf26869..987b823145870a 100644
--- a/net/websockets/websocket_channel.h
+++ b/net/websockets/websocket_channel.h
@@ -8,12 +8,12 @@
 #include <stdint.h>
 
 #include <memory>
-#include <queue>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"  // for WARN_UNUSED_RESULT
+#include "base/containers/queue.h"
 #include "base/i18n/streaming_utf8_validator.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -154,43 +154,7 @@ class NET_EXPORT WebSocketChannel {
 
  private:
   class HandshakeNotificationSender;
-
-  // The Windows implementation of std::queue requires that this declaration be
-  // visible in the header.
-  class PendingReceivedFrame {
-   public:
-    PendingReceivedFrame(bool final,
-                         WebSocketFrameHeader::OpCode opcode,
-                         scoped_refptr<IOBuffer> data,
-                         uint64_t offset,
-                         uint64_t size);
-    PendingReceivedFrame(const PendingReceivedFrame& other);
-    ~PendingReceivedFrame();
-
-    bool final() const { return final_; }
-    WebSocketFrameHeader::OpCode opcode() const { return opcode_; }
-    // ResetOpcode() to Continuation.
-    void ResetOpcode();
-    const scoped_refptr<IOBuffer>& data() const { return data_; }
-    uint64_t offset() const { return offset_; }
-    uint64_t size() const { return size_; }
-    // Increase |offset_| by |bytes|.
-    void DidConsume(uint64_t bytes);
-
-    // This object needs to be copyable and assignable, since it will be placed
-    // in a std::queue. The compiler-generated copy constructor and assignment
-    // operator will do the right thing.
-
-   private:
-    bool final_;
-    WebSocketFrameHeader::OpCode opcode_;
-    scoped_refptr<IOBuffer> data_;
-    // Where to start reading from data_. Everything prior to offset_ has
-    // already been sent to the browser.
-    uint64_t offset_;
-    // The size of data_.
-    uint64_t size_;
-  };
+  class PendingReceivedFrame;
 
   // The object passes through a linear progression of states from
   // FRESHLY_CONSTRUCTED to CLOSED, except that the SEND_CLOSED and RECV_CLOSED
@@ -390,7 +354,7 @@ class NET_EXPORT WebSocketChannel {
 
   // Frames that have been read but not yet forwarded to the renderer due to
   // lack of quota.
-  std::queue<PendingReceivedFrame> pending_received_frames_;
+  base::queue<PendingReceivedFrame> pending_received_frames_;
 
   // Handle to an in-progress WebSocketStream creation request. Only non-NULL
   // during the connection process.
diff --git a/net/websockets/websocket_deflate_stream_test.cc b/net/websockets/websocket_deflate_stream_test.cc
index db9bd875f36d68..0d5432ac3614cb 100644
--- a/net/websockets/websocket_deflate_stream_test.cc
+++ b/net/websockets/websocket_deflate_stream_test.cc
@@ -7,7 +7,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#include <deque>
 #include <iterator>
 #include <memory>
 #include <string>
@@ -15,6 +14,7 @@
 #include <vector>
 
 #include "base/bind.h"
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ -216,11 +216,11 @@ class WebSocketDeflatePredictorMock : public WebSocketDeflatePredictor {
   // Data frames which will be recorded by |RecordInputFrames|.
   // Pushed by |AddFrameToBeInput| and popped and verified by
   // |RecordInputFrames|.
-  std::deque<const WebSocketFrame*> frames_to_be_input_;
+  base::circular_deque<const WebSocketFrame*> frames_to_be_input_;
   // Data frames recorded by |RecordWrittenFrames|.
   // Pushed by |RecordWrittenFrames| and popped and verified by
   // |VerifySentFrame|.
-  std::deque<const WebSocketFrame*> frames_written_;
+  base::circular_deque<const WebSocketFrame*> frames_written_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketDeflatePredictorMock);
 };
diff --git a/net/websockets/websocket_deflater.cc b/net/websockets/websocket_deflater.cc
index 9e577ec33c3464..78e5b5264e601e 100644
--- a/net/websockets/websocket_deflater.cc
+++ b/net/websockets/websocket_deflater.cc
@@ -6,9 +6,9 @@
 
 #include <string.h>
 #include <algorithm>
-#include <deque>
 #include <vector>
 
+#include "base/containers/circular_deque.h"
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "third_party/zlib/zlib.h"
@@ -120,8 +120,8 @@ void WebSocketDeflater::PushSyncMark() {
 
 scoped_refptr<IOBufferWithSize> WebSocketDeflater::GetOutput(size_t size) {
   size_t length_to_copy = std::min(size, buffer_.size());
-  std::deque<char>::iterator begin = buffer_.begin();
-  std::deque<char>::iterator end = begin + length_to_copy;
+  base::circular_deque<char>::iterator begin = buffer_.begin();
+  base::circular_deque<char>::iterator end = begin + length_to_copy;
 
   scoped_refptr<IOBufferWithSize> result = new IOBufferWithSize(length_to_copy);
   std::copy(begin, end, result->data());
diff --git a/net/websockets/websocket_deflater.h b/net/websockets/websocket_deflater.h
index cf5b43b3b23dc1..369fff0de5d63d 100644
--- a/net/websockets/websocket_deflater.h
+++ b/net/websockets/websocket_deflater.h
@@ -7,10 +7,10 @@
 
 #include <stddef.h>
 
-#include <deque>
 #include <memory>
 #include <vector>
 
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/net_export.h"
@@ -67,7 +67,7 @@ class NET_EXPORT_PRIVATE WebSocketDeflater {
 
   std::unique_ptr<z_stream_s> stream_;
   ContextTakeOverMode mode_;
-  std::deque<char> buffer_;
+  base::circular_deque<char> buffer_;
   std::vector<char> fixed_buffer_;
   // true if bytes were added after last Finish().
   bool are_bytes_added_;
diff --git a/net/websockets/websocket_inflater.cc b/net/websockets/websocket_inflater.cc
index 7767821f462bf7..eac9e8c6ece548 100644
--- a/net/websockets/websocket_inflater.cc
+++ b/net/websockets/websocket_inflater.cc
@@ -5,7 +5,6 @@
 #include "net/websockets/websocket_inflater.h"
 
 #include <algorithm>
-#include <deque>
 #include <vector>
 
 #include "base/logging.h"
diff --git a/net/websockets/websocket_inflater.h b/net/websockets/websocket_inflater.h
index 8fe2b412289607..c861a10092c6f6 100644
--- a/net/websockets/websocket_inflater.h
+++ b/net/websockets/websocket_inflater.h
@@ -7,11 +7,11 @@
 
 #include <stddef.h>
 
-#include <deque>
 #include <memory>
 #include <utility>
 #include <vector>
 
+#include "base/containers/circular_deque.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "net/base/net_export.h"
@@ -113,7 +113,7 @@ class NET_EXPORT_PRIVATE WebSocketInflater {
     const size_t capacity_;
     size_t head_of_first_buffer_;
     size_t tail_of_last_buffer_;
-    std::deque<scoped_refptr<IOBufferWithSize> > buffers_;
+    base::circular_deque<scoped_refptr<IOBufferWithSize>> buffers_;
   };
 
   int InflateWithFlush(const char* next_in, size_t avail_in);