diff --git a/net/BUILD.gn b/net/BUILD.gn
index 81d59c8..3dcfa6b 100644
--- a/net/BUILD.gn
+++ b/net/BUILD.gn
@@ -551,8 +551,6 @@
   ]
 }
 
-if (false) {
-
 static_library("extras") {
   sources = gypi_values.net_extras_sources
   configs += [ "//build/config/compiler:wexit_time_destructors" ]
@@ -562,8 +560,6 @@
   ]
 }
 
-} # if (false)
-
 static_library("http_server") {
   sources = [
     "server/http_connection.cc",
@@ -1107,14 +1103,11 @@
 test("net_unittests") {
   sources = gypi_values.net_test_sources
 
-  sources -= [
-    "extras/sqlite/sqlite_channel_id_store_unittest.cc",
-  ]
-
   configs += [ ":net_win_size_truncation" ]
   defines = []
 
   deps = [
+    ":extras",
     ":http_server",
     ":net",
     ":quic_tools",
diff --git a/net/android/java/src/org/chromium/net/DefaultAndroidKeyStore.java b/net/android/java/src/org/chromium/net/DefaultAndroidKeyStore.java
index 167837c..3ee1029 100644
--- a/net/android/java/src/org/chromium/net/DefaultAndroidKeyStore.java
+++ b/net/android/java/src/org/chromium/net/DefaultAndroidKeyStore.java
@@ -109,7 +109,7 @@
                 signature = Signature.getInstance("NONEwithECDSA");
             }
         } catch (NoSuchAlgorithmException e) {
-            ;
+            // Intentionally do nothing.
         }
 
         if (signature == null) {
diff --git a/net/android/java/src/org/chromium/net/ProxyChangeListener.java b/net/android/java/src/org/chromium/net/ProxyChangeListener.java
index 51b6714..be09be4 100644
--- a/net/android/java/src/org/chromium/net/ProxyChangeListener.java
+++ b/net/android/java/src/org/chromium/net/ProxyChangeListener.java
@@ -36,16 +36,21 @@
     private Delegate mDelegate;
 
     private static class ProxyConfig {
-        public ProxyConfig(String host, int port, String pacUrl) {
+        public ProxyConfig(String host, int port, String pacUrl, String[] exclusionList) {
             mHost = host;
             mPort = port;
             mPacUrl = pacUrl;
+            mExclusionList = exclusionList;
         }
         public final String mHost;
         public final int mPort;
         public final String mPacUrl;
+        public final String[] mExclusionList;
     }
 
+    /**
+     * The delegate for ProxyChangeListener. Use for testing.
+     */
     public interface Delegate {
         public void proxySettingsChanged();
     }
@@ -104,6 +109,7 @@
                 final String getHostName = "getHost";
                 final String getPortName = "getPort";
                 final String getPacFileUrl = "getPacFileUrl";
+                final String getExclusionList = "getExclusionList";
                 String className;
                 String proxyInfo;
                 if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
@@ -122,27 +128,35 @@
                 Class<?> cls = Class.forName(className);
                 Method getHostMethod = cls.getDeclaredMethod(getHostName);
                 Method getPortMethod = cls.getDeclaredMethod(getPortName);
+                Method getExclusionListMethod = cls.getDeclaredMethod(getExclusionList);
 
                 String host = (String) getHostMethod.invoke(props);
                 int port = (Integer) getPortMethod.invoke(props);
 
+                String[] exclusionList;
+                if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.KITKAT) {
+                    String s = (String) getExclusionListMethod.invoke(props);
+                    exclusionList = s.split(",");
+                } else {
+                    exclusionList = (String[]) getExclusionListMethod.invoke(props);
+                }
                 // TODO(xunjieli): rewrite this once the API is public.
                 if (Build.VERSION.SDK_INT == Build.VERSION_CODES.KITKAT) {
                     Method getPacFileUrlMethod =
                         cls.getDeclaredMethod(getPacFileUrl);
                     String pacFileUrl = (String) getPacFileUrlMethod.invoke(props);
                     if (!TextUtils.isEmpty(pacFileUrl)) {
-                       return new ProxyConfig(host, port, pacFileUrl);
+                       return new ProxyConfig(host, port, pacFileUrl, exclusionList);
                     }
                 } else if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) {
                     Method getPacFileUrlMethod =
                         cls.getDeclaredMethod(getPacFileUrl);
                     Uri pacFileUrl = (Uri) getPacFileUrlMethod.invoke(props);
                     if (!Uri.EMPTY.equals(pacFileUrl)) {
-                      return new ProxyConfig(host, port, pacFileUrl.toString());
+                      return new ProxyConfig(host, port, pacFileUrl.toString(), exclusionList);
                     }
                 }
-                return new ProxyConfig(host, port, null);
+                return new ProxyConfig(host, port, null, exclusionList);
             } catch (ClassNotFoundException ex) {
                 Log.e(TAG, "Using no proxy configuration due to exception:" + ex);
                 return null;
@@ -175,7 +189,8 @@
         // Note that this code currently runs on a MESSAGE_LOOP_UI thread, but
         // the C++ code must run the callbacks on the network thread.
         if (cfg != null) {
-            nativeProxySettingsChangedTo(mNativePtr, cfg.mHost, cfg.mPort, cfg.mPacUrl);
+            nativeProxySettingsChangedTo(mNativePtr, cfg.mHost, cfg.mPort, cfg.mPacUrl,
+                    cfg.mExclusionList);
         } else {
             nativeProxySettingsChanged(mNativePtr);
         }
@@ -206,8 +221,8 @@
     private native void nativeProxySettingsChangedTo(long nativePtr,
                                                      String host,
                                                      int port,
-                                                     String pacUrl);
-
+                                                     String pacUrl,
+                                                     String[] exclusionList);
     @NativeClassQualifiedName("ProxyConfigServiceAndroid::JNIDelegate")
     private native void nativeProxySettingsChanged(long nativePtr);
 }
diff --git a/net/android/keystore_openssl.cc b/net/android/keystore_openssl.cc
index 1ca9bc1..c0f308d 100644
--- a/net/android/keystore_openssl.cc
+++ b/net/android/keystore_openssl.cc
@@ -95,7 +95,7 @@
   return 0;
 }
 
-// ExDataFree is called when one of the RSA, DSA or EC_KEY object is freed.
+// ExDataFree is called when one of the RSA, DSA or EC_KEY objects is freed.
 void ExDataFree(void* parent,
                 void* ptr,
                 CRYPTO_EX_DATA* ad,
@@ -204,7 +204,7 @@
   // Retrieve private key JNI reference.
   const KeyExData *ex_data = RsaGetExData(rsa);
   if (!ex_data || !ex_data->private_key) {
-    LOG(WARNING) << "Null JNI reference passed to RsaMethodPrivEnc!";
+    LOG(WARNING) << "Null JNI reference passed to RsaMethodSignRaw!";
     OPENSSL_PUT_ERROR(RSA, sign_raw, ERR_R_INTERNAL_ERROR);
     return 0;
   }
@@ -214,7 +214,7 @@
     int ret = ex_data->legacy_rsa->meth->rsa_priv_enc(
         in_len, in, out, ex_data->legacy_rsa, ANDROID_RSA_PKCS1_PADDING);
     if (ret < 0) {
-      LOG(WARNING) << "Could not sign message in RsaMethodPrivEnc!";
+      LOG(WARNING) << "Could not sign message in RsaMethodSignRaw!";
       // System OpenSSL will use a separate error queue, so it is still
       // necessary to push a new error.
       //
@@ -234,7 +234,7 @@
   // For RSA keys, this function behaves as RSA_private_encrypt with
   // PKCS#1 padding.
   if (!RawSignDigestWithPrivateKey(ex_data->private_key, from_piece, &result)) {
-    LOG(WARNING) << "Could not sign message in RsaMethodPrivEnc!";
+    LOG(WARNING) << "Could not sign message in RsaMethodSignRaw!";
     OPENSSL_PUT_ERROR(RSA, sign_raw, ERR_R_INTERNAL_ERROR);
     return 0;
   }
diff --git a/net/android/network_change_notifier_android.cc b/net/android/network_change_notifier_android.cc
index 2461d64..410d1fb 100644
--- a/net/android/network_change_notifier_android.cc
+++ b/net/android/network_change_notifier_android.cc
@@ -81,14 +81,14 @@
     Stop();
   }
 
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     address_tracker_.Init();
     dns_config_service_ = DnsConfigService::CreateSystemService();
     dns_config_service_->WatchConfig(
         base::Bind(&NetworkChangeNotifier::SetDnsConfig));
   }
 
-  virtual void CleanUp() OVERRIDE {
+  virtual void CleanUp() override {
     dns_config_service_.reset();
   }
 
diff --git a/net/android/network_change_notifier_android.h b/net/android/network_change_notifier_android.h
index e82b852..57d29b8 100644
--- a/net/android/network_change_notifier_android.h
+++ b/net/android/network_change_notifier_android.h
@@ -45,10 +45,10 @@
   virtual ~NetworkChangeNotifierAndroid();
 
   // NetworkChangeNotifier:
-  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE;
+  virtual ConnectionType GetCurrentConnectionType() const override;
 
   // NetworkChangeNotifierDelegateAndroid::Observer:
-  virtual void OnConnectionTypeChanged() OVERRIDE;
+  virtual void OnConnectionTypeChanged() override;
 
   static bool Register(JNIEnv* env);
 
diff --git a/net/android/network_change_notifier_android_unittest.cc b/net/android/network_change_notifier_android_unittest.cc
index 6ab894c..6aadb54 100644
--- a/net/android/network_change_notifier_android_unittest.cc
+++ b/net/android/network_change_notifier_android_unittest.cc
@@ -24,7 +24,7 @@
   NetworkChangeNotifierDelegateAndroidObserver() : notifications_count_(0) {}
 
   // NetworkChangeNotifierDelegateAndroid::Observer:
-  virtual void OnConnectionTypeChanged() OVERRIDE {
+  virtual void OnConnectionTypeChanged() override {
     notifications_count_++;
   }
 
@@ -43,7 +43,7 @@
 
   // NetworkChangeNotifier::Observer:
   virtual void OnConnectionTypeChanged(
-      NetworkChangeNotifier::ConnectionType connection_type) OVERRIDE {
+      NetworkChangeNotifier::ConnectionType connection_type) override {
     notifications_count_++;
   }
 
diff --git a/net/android/network_change_notifier_factory_android.h b/net/android/network_change_notifier_factory_android.h
index e71ec27..d443fcd 100644
--- a/net/android/network_change_notifier_factory_android.h
+++ b/net/android/network_change_notifier_factory_android.h
@@ -29,7 +29,7 @@
   virtual ~NetworkChangeNotifierFactoryAndroid();
 
   // NetworkChangeNotifierFactory:
-  virtual NetworkChangeNotifier* CreateInstance() OVERRIDE;
+  virtual NetworkChangeNotifier* CreateInstance() override;
 
  private:
   // Delegate passed to the instances created by this class.
diff --git a/net/base/address_tracker_linux.h b/net/base/address_tracker_linux.h
index ec52b60..2574fc7 100644
--- a/net/base/address_tracker_linux.h
+++ b/net/base/address_tracker_linux.h
@@ -108,8 +108,8 @@
   void AbortAndForceOnline();
 
   // MessageLoopForIO::Watcher:
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
-  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE;
+  virtual void OnFileCanReadWithoutBlocking(int fd) override;
+  virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override;
 
   // Close |netlink_fd_|
   void CloseSocket();
diff --git a/net/base/backoff_entry_unittest.cc b/net/base/backoff_entry_unittest.cc
index 560b213..f5393e8 100644
--- a/net/base/backoff_entry_unittest.cc
+++ b/net/base/backoff_entry_unittest.cc
@@ -25,7 +25,7 @@
 
   virtual ~TestBackoffEntry() {}
 
-  virtual TimeTicks ImplGetTimeNow() const OVERRIDE {
+  virtual TimeTicks ImplGetTimeNow() const override {
     return now_;
   }
 
diff --git a/net/base/capturing_net_log.h b/net/base/capturing_net_log.h
index 06bc976..a58b6ff 100644
--- a/net/base/capturing_net_log.h
+++ b/net/base/capturing_net_log.h
@@ -105,7 +105,7 @@
 
    private:
     // ThreadSafeObserver implementation:
-    virtual void OnAddEntry(const Entry& entry) OVERRIDE;
+    virtual void OnAddEntry(const Entry& entry) override;
 
     // Needs to be "mutable" so can use it in GetEntries().
     mutable base::Lock lock_;
diff --git a/net/base/chunked_upload_data_stream.cc b/net/base/chunked_upload_data_stream.cc
new file mode 100644
index 0000000..f1fbf08
--- /dev/null
+++ b/net/base/chunked_upload_data_stream.cc
@@ -0,0 +1,103 @@
+// 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 "net/base/chunked_upload_data_stream.h"
+
+#include "base/logging.h"
+#include "base/stl_util.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+
+namespace net {
+
+ChunkedUploadDataStream::ChunkedUploadDataStream(int64 identifier)
+    : UploadDataStream(true, identifier),
+      read_index_(0),
+      read_offset_(0),
+      all_data_appended_(false),
+      read_buffer_len_(0) {
+}
+
+ChunkedUploadDataStream::~ChunkedUploadDataStream() {
+}
+
+void ChunkedUploadDataStream::AppendData(
+    const char* data, int data_len, bool is_done) {
+  DCHECK(!all_data_appended_);
+  DCHECK(data_len > 0 || is_done);
+  if (data_len > 0) {
+    DCHECK(data);
+    upload_data_.push_back(new std::vector<char>(data, data + data_len));
+  }
+  all_data_appended_ = is_done;
+
+  if (!read_buffer_.get())
+    return;
+
+  int result = ReadChunk(read_buffer_.get(), read_buffer_len_);
+  // Shouldn't get an error or ERR_IO_PENDING.
+  DCHECK_GE(result, 0);
+  read_buffer_ = NULL;
+  read_buffer_len_ = 0;
+  OnReadCompleted(result);
+}
+
+int ChunkedUploadDataStream::InitInternal() {
+  // ResetInternal should already have been called.
+  DCHECK(!read_buffer_.get());
+  DCHECK_EQ(0u, read_index_);
+  DCHECK_EQ(0u, read_offset_);
+  return OK;
+}
+
+int ChunkedUploadDataStream::ReadInternal(IOBuffer* buf, int buf_len) {
+  DCHECK_LT(0, buf_len);
+  DCHECK(!read_buffer_.get());
+
+  int result = ReadChunk(buf, buf_len);
+  if (result == ERR_IO_PENDING) {
+    read_buffer_ = buf;
+    read_buffer_len_ = buf_len;
+  }
+  return result;
+}
+
+void ChunkedUploadDataStream::ResetInternal() {
+  read_buffer_ = NULL;
+  read_buffer_len_ = 0;
+  read_index_ = 0;
+  read_offset_ = 0;
+}
+
+int ChunkedUploadDataStream::ReadChunk(IOBuffer* buf, int buf_len) {
+  // Copy as much data as possible from |upload_data_| to |buf|.
+  int bytes_read = 0;
+  while (read_index_ < upload_data_.size() && bytes_read < buf_len) {
+    std::vector<char>* data = upload_data_[read_index_];
+    size_t bytes_to_read =
+        std::min(static_cast<size_t>(buf_len - bytes_read),
+                 data->size() - read_offset_);
+    memcpy(buf->data() + bytes_read,
+           vector_as_array(data) + read_offset_,
+           bytes_to_read);
+    bytes_read += bytes_to_read;
+    read_offset_ += bytes_to_read;
+    if (read_offset_ == data->size()) {
+      read_index_++;
+      read_offset_ = 0;
+    }
+  }
+  DCHECK_LE(bytes_read, buf_len);
+
+  // If no data was written, and not all data has been appended, return
+  // ERR_IO_PENDING. The read will be completed in the next call to AppendData.
+  if (bytes_read == 0 && !all_data_appended_)
+    return ERR_IO_PENDING;
+
+  if (read_index_ == upload_data_.size() && all_data_appended_)
+    SetIsFinalChunk();
+  return bytes_read;
+}
+
+}  // namespace net
diff --git a/net/base/chunked_upload_data_stream.h b/net/base/chunked_upload_data_stream.h
new file mode 100644
index 0000000..71b1e5c
--- /dev/null
+++ b/net/base/chunked_upload_data_stream.h
@@ -0,0 +1,63 @@
+// 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.
+
+#ifndef NET_BASE_CHUNKED_UPLOAD_DATA_STREAM_H_
+#define NET_BASE_CHUNKED_UPLOAD_DATA_STREAM_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_vector.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_export.h"
+#include "net/base/upload_data_stream.h"
+
+namespace net {
+
+class IOBuffer;
+
+// Class with a push-based interface for uploading data. Buffers all data until
+// the request is completed. Not recommended for uploading large amounts of
+// seekable data, due to this buffering behavior.
+class NET_EXPORT ChunkedUploadDataStream : public UploadDataStream {
+ public:
+  ChunkedUploadDataStream(int64 identifier);
+
+  virtual ~ChunkedUploadDataStream();
+
+  // Adds data to the stream. |is_done| should be true if this is the last
+  // data to be appended. |data_len| must not be 0 unless |is_done| is true.
+  // Once called with |is_done| being true, must never be called again.
+  // TODO(mmenke):  Consider using IOBuffers instead, to reduce data copies.
+  void AppendData(const char* data, int data_len, bool is_done);
+
+ private:
+  // UploadDataStream implementation.
+  virtual int InitInternal() override;
+  virtual int ReadInternal(IOBuffer* buf, int buf_len) override;
+  virtual void ResetInternal() override;
+
+  int ReadChunk(IOBuffer* buf, int buf_len);
+
+  // Index and offset of next element of |upload_data_| to be read.
+  size_t read_index_;
+  size_t read_offset_;
+
+  // True once all data has been appended to the stream.
+  bool all_data_appended_;
+
+  ScopedVector<std::vector<char>> upload_data_;
+
+  // Buffer to write the next read's data to. Only set when a call to
+  // ReadInternal reads no data.
+  scoped_refptr<IOBuffer> read_buffer_;
+  int read_buffer_len_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChunkedUploadDataStream);
+};
+
+}  // namespace net
+
+#endif  // NET_BASE_CHUNKED_UPLOAD_DATA_STREAM_H_
diff --git a/net/base/chunked_upload_data_stream_unittest.cc b/net/base/chunked_upload_data_stream_unittest.cc
new file mode 100644
index 0000000..334e9a3
--- /dev/null
+++ b/net/base/chunked_upload_data_stream_unittest.cc
@@ -0,0 +1,308 @@
+// 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 "net/base/chunked_upload_data_stream.h"
+
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/base/test_completion_callback.h"
+#include "net/base/upload_data_stream.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace net {
+
+namespace {
+
+const char kTestData[] = "0123456789";
+const size_t kTestDataSize = arraysize(kTestData) - 1;
+const size_t kTestBufferSize = 1 << 14;  // 16KB.
+
+}  // namespace
+
+// Reads data once from the upload data stream, and returns the data as string.
+// Expects the read to succeed synchronously.
+std::string ReadSync(UploadDataStream* stream, int buffer_size) {
+  scoped_refptr<IOBuffer> buf = new IOBuffer(buffer_size);
+  int result = stream->Read(buf.get(),
+                            buffer_size,
+                            TestCompletionCallback().callback());
+  EXPECT_GE(result, 0);
+  return std::string(buf->data(), result);
+}
+
+// Check the case data is added after the first read attempt.
+TEST(ChunkedUploadDataStreamTest, AppendOnce) {
+  ChunkedUploadDataStream stream(0);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
+  int result = stream.Read(buf.get(), kTestBufferSize, callback.callback());
+  ASSERT_EQ(ERR_IO_PENDING, result);
+
+  stream.AppendData(kTestData, kTestDataSize, true);
+  int read = callback.WaitForResult();
+  ASSERT_GE(read, 0);
+  EXPECT_EQ(kTestData, std::string(buf->data(), read));
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(kTestDataSize, stream.position());
+  EXPECT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, AppendOnceBeforeRead) {
+  ChunkedUploadDataStream stream(0);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  stream.AppendData(kTestData, kTestDataSize, true);
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  std::string data = ReadSync(&stream, kTestBufferSize);
+  EXPECT_EQ(kTestData, data);
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(kTestDataSize, stream.position());
+  EXPECT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, AppendOnceBeforeInit) {
+  ChunkedUploadDataStream stream(0);
+
+  stream.AppendData(kTestData, kTestDataSize, true);
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  std::string data = ReadSync(&stream, kTestBufferSize);
+  EXPECT_EQ(kTestData, data);
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(kTestDataSize, stream.position());
+  EXPECT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, MultipleAppends) {
+  ChunkedUploadDataStream stream(0);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
+  for (size_t i = 0; i < kTestDataSize; ++i) {
+    EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+    EXPECT_EQ(i, stream.position());
+    ASSERT_FALSE(stream.IsEOF());
+    int bytes_read = stream.Read(buf.get(),
+                                 kTestBufferSize,
+                                 callback.callback());
+    ASSERT_EQ(ERR_IO_PENDING, bytes_read);
+    stream.AppendData(&kTestData[i], 1, i == kTestDataSize - 1);
+    ASSERT_EQ(1, callback.WaitForResult());
+    EXPECT_EQ(kTestData[i], buf->data()[0]);
+  }
+
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(kTestDataSize, stream.position());
+  ASSERT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, MultipleAppendsBetweenReads) {
+  ChunkedUploadDataStream stream(0);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
+  for (size_t i = 0; i < kTestDataSize; ++i) {
+    EXPECT_EQ(i, stream.position());
+    ASSERT_FALSE(stream.IsEOF());
+    stream.AppendData(&kTestData[i], 1, i == kTestDataSize - 1);
+    int bytes_read = stream.Read(buf.get(),
+                                 kTestBufferSize,
+                                 TestCompletionCallback().callback());
+    ASSERT_EQ(1, bytes_read);
+    EXPECT_EQ(kTestData[i], buf->data()[0]);
+  }
+
+  EXPECT_EQ(kTestDataSize, stream.position());
+  ASSERT_TRUE(stream.IsEOF());
+}
+
+// Checks that multiple reads can be merged.
+TEST(ChunkedUploadDataStreamTest, MultipleAppendsBeforeInit) {
+  ChunkedUploadDataStream stream(0);
+  stream.AppendData(kTestData, 1, false);
+  stream.AppendData(kTestData + 1, 1, false);
+  stream.AppendData(kTestData + 2, kTestDataSize - 2, true);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  std::string data = ReadSync(&stream, kTestBufferSize);
+  EXPECT_EQ(kTestData, data);
+  EXPECT_EQ(kTestDataSize, stream.position());
+  ASSERT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, MultipleReads) {
+  // Use a read size different from the write size to test bounds checking.
+  const size_t kReadSize = kTestDataSize + 3;
+
+  ChunkedUploadDataStream stream(0);
+  stream.AppendData(kTestData, kTestDataSize, false);
+  stream.AppendData(kTestData, kTestDataSize, false);
+  stream.AppendData(kTestData, kTestDataSize, false);
+  stream.AppendData(kTestData, kTestDataSize, true);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  std::string data = ReadSync(&stream, kReadSize);
+  EXPECT_EQ("0123456789012", data);
+  EXPECT_EQ(kReadSize, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  data = ReadSync(&stream, kReadSize);
+  EXPECT_EQ("3456789012345", data);
+  EXPECT_EQ(2 * kReadSize, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  data = ReadSync(&stream, kReadSize);
+  EXPECT_EQ("6789012345678", data);
+  EXPECT_EQ(3 * kReadSize, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  data = ReadSync(&stream, kReadSize);
+  EXPECT_EQ("9", data);
+  EXPECT_EQ(4 * kTestDataSize, stream.position());
+  EXPECT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, EmptyUpload) {
+  ChunkedUploadDataStream stream(0);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
+  int result = stream.Read(buf.get(), kTestBufferSize, callback.callback());
+  ASSERT_EQ(ERR_IO_PENDING, result);
+
+  stream.AppendData(NULL, 0, true);
+  int read = callback.WaitForResult();
+  EXPECT_EQ(0, read);
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, EmptyUploadEndedBeforeInit) {
+  ChunkedUploadDataStream stream(0);
+  stream.AppendData(NULL, 0, true);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  std::string data = ReadSync(&stream, kTestBufferSize);
+  ASSERT_EQ("", data);
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, RewindAfterComplete) {
+  ChunkedUploadDataStream stream(0);
+  stream.AppendData(kTestData, 1, false);
+  stream.AppendData(kTestData + 1, kTestDataSize - 1, true);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  std::string data = ReadSync(&stream, kTestBufferSize);
+  EXPECT_EQ(kTestData, data);
+  EXPECT_EQ(kTestDataSize, stream.position());
+  ASSERT_TRUE(stream.IsEOF());
+
+  // Rewind stream and repeat.
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  data = ReadSync(&stream, kTestBufferSize);
+  EXPECT_EQ(kTestData, data);
+  EXPECT_EQ(kTestDataSize, stream.position());
+  ASSERT_TRUE(stream.IsEOF());
+}
+
+TEST(ChunkedUploadDataStreamTest, RewindWhileReading) {
+  ChunkedUploadDataStream stream(0);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  TestCompletionCallback callback;
+  scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
+  int result = stream.Read(buf.get(), kTestBufferSize, callback.callback());
+  ASSERT_EQ(ERR_IO_PENDING, result);
+
+  ASSERT_EQ(OK, stream.Init(TestCompletionCallback().callback()));
+  EXPECT_FALSE(stream.IsInMemory());
+  EXPECT_EQ(0u, stream.size());  // Content-Length is 0 for chunked data.
+  EXPECT_EQ(0u, stream.position());
+  EXPECT_FALSE(stream.IsEOF());
+
+  // Adding data now should not result in calling the original read callback,
+  // since the stream was re-initialized for reuse, which cancels all pending
+  // reads.
+  stream.AppendData(kTestData, kTestDataSize, true);
+  EXPECT_FALSE(callback.have_result());
+
+  std::string data = ReadSync(&stream, kTestBufferSize);
+  EXPECT_EQ(kTestData, data);
+  EXPECT_EQ(kTestDataSize, stream.position());
+  ASSERT_TRUE(stream.IsEOF());
+  EXPECT_FALSE(callback.have_result());
+}
+
+}  // namespace net
diff --git a/net/base/directory_lister_unittest.cc b/net/base/directory_lister_unittest.cc
index 970f0d7..f52e23e 100644
--- a/net/base/directory_lister_unittest.cc
+++ b/net/base/directory_lister_unittest.cc
@@ -28,14 +28,14 @@
   }
 
   virtual void OnListFile(
-      const DirectoryLister::DirectoryListerData& data) OVERRIDE {
+      const DirectoryLister::DirectoryListerData& data) override {
     file_list_.push_back(data.info);
     paths_.push_back(data.path);
     if (quit_loop_after_each_file_)
       base::MessageLoop::current()->Quit();
   }
 
-  virtual void OnListDone(int error) OVERRIDE {
+  virtual void OnListDone(int error) override {
     error_ = error;
     base::MessageLoop::current()->Quit();
     if (recursive_)
@@ -93,7 +93,7 @@
 class DirectoryListerTest : public PlatformTest {
  public:
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     const int kMaxDepth = 3;
     const int kBranchingFactor = 4;
     const int kFilesPerDirectory = 5;
diff --git a/net/base/dns_reloader.cc b/net/base/dns_reloader.cc
index 04abcb1..3a92418 100644
--- a/net/base/dns_reloader.cc
+++ b/net/base/dns_reloader.cc
@@ -46,7 +46,7 @@
   };
 
   // NetworkChangeNotifier::DNSObserver:
-  virtual void OnDNSChanged() OVERRIDE {
+  virtual void OnDNSChanged() override {
     DCHECK(base::MessageLoopForIO::IsCurrent());
     base::AutoLock l(lock_);
     resolver_generation_++;
@@ -110,7 +110,7 @@
 namespace net {
 
 void EnsureDnsReloaderInit() {
-  DnsReloader* t ALLOW_UNUSED = g_dns_reloader.Pointer();
+  g_dns_reloader.Pointer();
 }
 
 void DnsReloaderMaybeReload() {
diff --git a/net/base/elements_upload_data_stream.cc b/net/base/elements_upload_data_stream.cc
new file mode 100644
index 0000000..86ea28c
--- /dev/null
+++ b/net/base/elements_upload_data_stream.cc
@@ -0,0 +1,166 @@
+// 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 "net/base/elements_upload_data_stream.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "net/base/completion_callback.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_element_reader.h"
+
+namespace net {
+
+ElementsUploadDataStream::ElementsUploadDataStream(
+    ScopedVector<UploadElementReader> element_readers,
+    int64 identifier)
+    : UploadDataStream(false, identifier),
+      element_readers_(element_readers.Pass()),
+      element_index_(0),
+      read_failed_(false),
+      weak_ptr_factory_(this) {
+}
+
+ElementsUploadDataStream::~ElementsUploadDataStream() {
+}
+
+scoped_ptr<UploadDataStream> ElementsUploadDataStream::CreateWithReader(
+    scoped_ptr<UploadElementReader> reader,
+    int64 identifier) {
+  ScopedVector<UploadElementReader> readers;
+  readers.push_back(reader.release());
+  return scoped_ptr<UploadDataStream>(
+      new ElementsUploadDataStream(readers.Pass(), identifier));
+}
+
+int ElementsUploadDataStream::InitInternal() {
+  return InitElements(0);
+}
+
+int ElementsUploadDataStream::ReadInternal(
+    IOBuffer* buf,
+    int buf_len) {
+  DCHECK_GT(buf_len, 0);
+  return ReadElements(new DrainableIOBuffer(buf, buf_len));
+}
+
+bool ElementsUploadDataStream::IsInMemory() const {
+  for (size_t i = 0; i < element_readers_.size(); ++i) {
+    if (!element_readers_[i]->IsInMemory())
+      return false;
+  }
+  return true;
+}
+
+const ScopedVector<UploadElementReader>*
+ElementsUploadDataStream::GetElementReaders() const {
+  return &element_readers_;
+}
+
+void ElementsUploadDataStream::ResetInternal() {
+  weak_ptr_factory_.InvalidateWeakPtrs();
+  read_failed_ = false;
+  element_index_ = 0;
+}
+
+int ElementsUploadDataStream::InitElements(size_t start_index) {
+  // Call Init() for all elements.
+  for (size_t i = start_index; i < element_readers_.size(); ++i) {
+    UploadElementReader* reader = element_readers_[i];
+    // When new_result is ERR_IO_PENDING, InitInternal() will be called
+    // with start_index == i + 1 when reader->Init() finishes.
+    int result = reader->Init(
+        base::Bind(&ElementsUploadDataStream::OnInitElementCompleted,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   i));
+    DCHECK(result != ERR_IO_PENDING || !reader->IsInMemory());
+    DCHECK_LE(result, OK);
+    if (result != OK)
+      return result;
+  }
+
+  uint64 total_size = 0;
+  for (size_t i = 0; i < element_readers_.size(); ++i) {
+    total_size += element_readers_[i]->GetContentLength();
+  }
+  SetSize(total_size);
+  return OK;
+}
+
+void ElementsUploadDataStream::OnInitElementCompleted(size_t index,
+                                                      int result) {
+  DCHECK_NE(ERR_IO_PENDING, result);
+
+  // Check the last result.
+  if (result == OK)
+    result = InitElements(index + 1);
+
+  if (result != ERR_IO_PENDING)
+    OnInitCompleted(result);
+}
+
+int ElementsUploadDataStream::ReadElements(
+    const scoped_refptr<DrainableIOBuffer>& buf) {
+  while (!read_failed_ && element_index_ < element_readers_.size()) {
+    UploadElementReader* reader = element_readers_[element_index_];
+
+    if (reader->BytesRemaining() == 0) {
+      ++element_index_;
+      continue;
+    }
+
+    if (buf->BytesRemaining() == 0)
+      break;
+
+    int result = reader->Read(
+        buf.get(),
+        buf->BytesRemaining(),
+        base::Bind(&ElementsUploadDataStream::OnReadElementCompleted,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   buf));
+    if (result == ERR_IO_PENDING)
+      return ERR_IO_PENDING;
+    ProcessReadResult(buf, result);
+  }
+
+  if (read_failed_) {
+    // If an error occured during read operation, then pad with zero.
+    // Otherwise the server will hang waiting for the rest of the data.
+    int num_bytes_to_fill = std::min(
+        static_cast<uint64>(buf->BytesRemaining()),
+        size() - position() - buf->BytesConsumed());
+    DCHECK_LE(0, num_bytes_to_fill);
+    memset(buf->data(), 0, num_bytes_to_fill);
+    buf->DidConsume(num_bytes_to_fill);
+  }
+
+  return buf->BytesConsumed();
+}
+
+void ElementsUploadDataStream::OnReadElementCompleted(
+    const scoped_refptr<DrainableIOBuffer>& buf,
+    int result) {
+  ProcessReadResult(buf, result);
+
+  result = ReadElements(buf);
+  if (result != ERR_IO_PENDING)
+    OnReadCompleted(result);
+}
+
+void ElementsUploadDataStream::ProcessReadResult(
+    const scoped_refptr<DrainableIOBuffer>& buf,
+    int result) {
+  DCHECK_NE(ERR_IO_PENDING, result);
+  DCHECK(!read_failed_);
+
+  if (result >= 0) {
+    buf->DidConsume(result);
+  } else {
+    read_failed_ = true;
+  }
+}
+
+}  // namespace net
diff --git a/net/base/elements_upload_data_stream.h b/net/base/elements_upload_data_stream.h
new file mode 100644
index 0000000..1a008fc
--- /dev/null
+++ b/net/base/elements_upload_data_stream.h
@@ -0,0 +1,86 @@
+// 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 NET_BASE_ELEMENTS_UPLOAD_DATA_STREAM_H_
+#define NET_BASE_ELEMENTS_UPLOAD_DATA_STREAM_H_
+
+#include "base/basictypes.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
+#include "base/memory/weak_ptr.h"
+#include "net/base/net_export.h"
+#include "net/base/upload_data_stream.h"
+
+namespace net {
+
+class DrainableIOBuffer;
+class IOBuffer;
+class UploadElementReader;
+
+// A non-chunked UploadDataStream consisting of one or more UploadElements.
+class NET_EXPORT ElementsUploadDataStream : public UploadDataStream {
+ public:
+  ElementsUploadDataStream(ScopedVector<UploadElementReader> element_readers,
+                           int64 identifier);
+
+  virtual ~ElementsUploadDataStream();
+
+  // Creates an ElementsUploadDataStream with a single reader.  Returns a
+  // scoped_ptr<UploadDataStream> for ease of use.
+  static scoped_ptr<UploadDataStream> CreateWithReader(
+      scoped_ptr<UploadElementReader> reader,
+      int64 identifier);
+
+ private:
+  // UploadDataStream implementation.
+  virtual bool IsInMemory() const override;
+  virtual const ScopedVector<UploadElementReader>*
+     GetElementReaders() const override;
+  virtual int InitInternal() override;
+  virtual int ReadInternal(IOBuffer* buf, int buf_len) override;
+  virtual void ResetInternal() override;
+
+  // Runs Init() for all element readers.
+  // This method is used to implement InitInternal().
+  int InitElements(size_t start_index);
+
+  // Called when the |index| element finishes initialization. If it succeeded,
+  // continues with the |index + 1| element. Calls OnInitCompleted on error or
+  // when all elements have been initialized.
+  void OnInitElementCompleted(size_t index, int result);
+
+  // Reads data from the element readers.
+  // This method is used to implement Read().
+  int ReadElements(const scoped_refptr<DrainableIOBuffer>& buf);
+
+  // Resumes pending read and calls OnReadCompleted with a result when
+  // necessary.
+  void OnReadElementCompleted(const scoped_refptr<DrainableIOBuffer>& buf,
+                              int result);
+
+  // Processes result of UploadElementReader::Read(). If |result| indicates
+  // success, updates |buf|'s offset. Otherwise, sets |read_failed_| to true.
+  void ProcessReadResult(const scoped_refptr<DrainableIOBuffer>& buf,
+                         int result);
+
+  ScopedVector<UploadElementReader> element_readers_;
+
+  // Index of the current upload element (i.e. the element currently being
+  // read). The index is used as a cursor to iterate over elements in
+  // |upload_data_|.
+  size_t element_index_;
+
+  // True if an error occcured during read operation.
+  bool read_failed_;
+
+  base::WeakPtrFactory<ElementsUploadDataStream> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ElementsUploadDataStream);
+};
+
+}  // namespace net
+
+#endif  // NET_BASE_ELEMENTS_UPLOAD_DATA_STREAM_H_
diff --git a/net/base/upload_data_stream_unittest.cc b/net/base/elements_upload_data_stream_unittest.cc
similarity index 71%
rename from net/base/upload_data_stream_unittest.cc
rename to net/base/elements_upload_data_stream_unittest.cc
index 2df38cd..91c390c 100644
--- a/net/base/upload_data_stream_unittest.cc
+++ b/net/base/elements_upload_data_stream_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/base/upload_data_stream.h"
+#include "net/base/elements_upload_data_stream.h"
 
 #include <algorithm>
 #include <vector>
@@ -20,6 +20,7 @@
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
+#include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -67,9 +68,9 @@
 
   // UploadElementReader overrides.
   MOCK_METHOD1(Init, int(const CompletionCallback& callback));
-  virtual uint64 GetContentLength() const OVERRIDE { return content_length_; }
-  virtual uint64 BytesRemaining() const OVERRIDE { return bytes_remaining_; }
-  virtual bool IsInMemory() const OVERRIDE { return is_in_memory_; }
+  virtual uint64 GetContentLength() const override { return content_length_; }
+  virtual uint64 BytesRemaining() const override { return bytes_remaining_; }
+  virtual bool IsInMemory() const override { return is_in_memory_; }
   MOCK_METHOD3(Read, int(IOBuffer* buf,
                          int buf_length,
                          const CompletionCallback& callback));
@@ -122,13 +123,13 @@
 
 }  // namespace
 
-class UploadDataStreamTest : public PlatformTest {
+class ElementsUploadDataStreamTest : public PlatformTest {
  public:
   virtual void SetUp() {
     PlatformTest::SetUp();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
-  virtual ~UploadDataStreamTest() {
+  virtual ~ElementsUploadDataStreamTest() {
     element_readers_.clear();
     base::RunLoop().RunUntilIdle();
   }
@@ -141,35 +142,37 @@
   ScopedVector<UploadElementReader> element_readers_;
 };
 
-TEST_F(UploadDataStreamTest, EmptyUploadData) {
-  UploadDataStream stream(element_readers_.Pass(), 0);
-  ASSERT_EQ(OK, stream.Init(CompletionCallback()));
-  EXPECT_TRUE(stream.IsInMemory());
-  EXPECT_EQ(0U, stream.size());
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_TRUE(stream.IsEOF());
+TEST_F(ElementsUploadDataStreamTest, EmptyUploadData) {
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+  ASSERT_EQ(OK, stream->Init(CompletionCallback()));
+  EXPECT_TRUE(stream->IsInMemory());
+  EXPECT_EQ(0U, stream->size());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_TRUE(stream->IsEOF());
 }
 
-TEST_F(UploadDataStreamTest, ConsumeAllBytes) {
+TEST_F(ElementsUploadDataStreamTest, ConsumeAllBytes) {
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
-  UploadDataStream stream(element_readers_.Pass(), 0);
-  ASSERT_EQ(OK, stream.Init(CompletionCallback()));
-  EXPECT_TRUE(stream.IsInMemory());
-  EXPECT_EQ(kTestDataSize, stream.size());
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_FALSE(stream.IsEOF());
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+  ASSERT_EQ(OK, stream->Init(CompletionCallback()));
+  EXPECT_TRUE(stream->IsInMemory());
+  EXPECT_EQ(kTestDataSize, stream->size());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
-  while (!stream.IsEOF()) {
+  while (!stream->IsEOF()) {
     int bytes_read =
-        stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
+        stream->Read(buf.get(), kTestBufferSize, CompletionCallback());
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
-  EXPECT_EQ(kTestDataSize, stream.position());
-  ASSERT_TRUE(stream.IsEOF());
+  EXPECT_EQ(kTestDataSize, stream->position());
+  ASSERT_TRUE(stream->IsEOF());
 }
 
-TEST_F(UploadDataStreamTest, File) {
+TEST_F(ElementsUploadDataStreamTest, File) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -184,26 +187,27 @@
                                   base::Time()));
 
   TestCompletionCallback init_callback;
-  UploadDataStream stream(element_readers_.Pass(), 0);
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
-  EXPECT_FALSE(stream.IsInMemory());
-  EXPECT_EQ(kTestDataSize, stream.size());
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_FALSE(stream.IsEOF());
+  EXPECT_FALSE(stream->IsInMemory());
+  EXPECT_EQ(kTestDataSize, stream->size());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
-  while (!stream.IsEOF()) {
+  while (!stream->IsEOF()) {
     TestCompletionCallback read_callback;
     ASSERT_EQ(
         ERR_IO_PENDING,
-        stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
+        stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
     ASSERT_LE(0, read_callback.WaitForResult());  // Not an error.
   }
-  EXPECT_EQ(kTestDataSize, stream.position());
-  ASSERT_TRUE(stream.IsEOF());
+  EXPECT_EQ(kTestDataSize, stream->position());
+  ASSERT_TRUE(stream->IsEOF());
 }
 
-TEST_F(UploadDataStreamTest, FileSmallerThanLength) {
+TEST_F(ElementsUploadDataStreamTest, FileSmallerThanLength) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -222,32 +226,33 @@
                                   base::Time()));
 
   TestCompletionCallback init_callback;
-  UploadDataStream stream(element_readers_.Pass(), 0);
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
-  EXPECT_FALSE(stream.IsInMemory());
-  EXPECT_EQ(kFakeSize, stream.size());
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_FALSE(stream.IsEOF());
+  EXPECT_FALSE(stream->IsInMemory());
+  EXPECT_EQ(kFakeSize, stream->size());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
   uint64 read_counter = 0;
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
-  while (!stream.IsEOF()) {
+  while (!stream->IsEOF()) {
     TestCompletionCallback read_callback;
     ASSERT_EQ(
         ERR_IO_PENDING,
-        stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
+        stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
     int bytes_read = read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
     read_counter += bytes_read;
-    EXPECT_EQ(read_counter, stream.position());
+    EXPECT_EQ(read_counter, stream->position());
   }
   // UpdateDataStream will pad out the file with 0 bytes so that the HTTP
   // transaction doesn't hang.  Therefore we expected the full size.
   EXPECT_EQ(kFakeSize, read_counter);
-  EXPECT_EQ(read_counter, stream.position());
+  EXPECT_EQ(read_counter, stream->position());
 }
 
-TEST_F(UploadDataStreamTest, ReadErrorSync) {
+TEST_F(ElementsUploadDataStreamTest, ReadErrorSync) {
   // This element cannot be read.
   MockUploadElementReader* reader =
       new MockUploadElementReader(kTestDataSize, true);
@@ -259,13 +264,14 @@
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
 
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   // Run Init().
-  ASSERT_EQ(OK, stream.Init(CompletionCallback()));
-  EXPECT_EQ(kTestDataSize*2, stream.size());
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_FALSE(stream.IsEOF());
+  ASSERT_EQ(OK, stream->Init(CompletionCallback()));
+  EXPECT_EQ(kTestDataSize*2, stream->size());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
@@ -273,16 +279,16 @@
 
   // Read() results in success even when the reader returns error.
   EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
-            stream.Read(buf.get(), kTestBufferSize, CompletionCallback()));
-  EXPECT_EQ(kTestDataSize * 2, stream.position());
-  EXPECT_TRUE(stream.IsEOF());
+            stream->Read(buf.get(), kTestBufferSize, CompletionCallback()));
+  EXPECT_EQ(kTestDataSize * 2, stream->position());
+  EXPECT_TRUE(stream->IsEOF());
 
   // The buffer is filled with zero.
   EXPECT_EQ(static_cast<int>(kTestDataSize*2),
             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
-TEST_F(UploadDataStreamTest, ReadErrorAsync) {
+TEST_F(ElementsUploadDataStreamTest, ReadErrorAsync) {
   // This element cannot be read.
   MockUploadElementReader* reader =
       new MockUploadElementReader(kTestDataSize, false);
@@ -294,15 +300,16 @@
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
 
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   // Run Init().
   TestCompletionCallback init_callback;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   EXPECT_EQ(OK, init_callback.WaitForResult());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_FALSE(stream.IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
 
   // Prepare a buffer filled with non-zero data.
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
@@ -311,17 +318,17 @@
   // Read() results in success even when the reader returns error.
   TestCompletionCallback read_callback;
   ASSERT_EQ(ERR_IO_PENDING,
-            stream.Read(buf.get(), kTestBufferSize, read_callback.callback()));
+            stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
   EXPECT_EQ(static_cast<int>(kTestDataSize * 2), read_callback.WaitForResult());
-  EXPECT_EQ(kTestDataSize*2, stream.position());
-  EXPECT_TRUE(stream.IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->position());
+  EXPECT_TRUE(stream->IsEOF());
 
   // The buffer is filled with zero.
   EXPECT_EQ(static_cast<int>(kTestDataSize*2),
             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
-TEST_F(UploadDataStreamTest, FileAndBytes) {
+TEST_F(ElementsUploadDataStreamTest, FileAndBytes) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -342,49 +349,29 @@
 
   const uint64 kStreamSize = kTestDataSize + kFileRangeLength;
   TestCompletionCallback init_callback;
-  UploadDataStream stream(element_readers_.Pass(), 0);
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
-  EXPECT_FALSE(stream.IsInMemory());
-  EXPECT_EQ(kStreamSize, stream.size());
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_FALSE(stream.IsEOF());
+  EXPECT_FALSE(stream->IsInMemory());
+  EXPECT_EQ(kStreamSize, stream->size());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
-  while (!stream.IsEOF()) {
+  while (!stream->IsEOF()) {
     TestCompletionCallback read_callback;
     const int result =
-        stream.Read(buf.get(), kTestBufferSize, read_callback.callback());
+        stream->Read(buf.get(), kTestBufferSize, read_callback.callback());
     const int bytes_read =
         result != ERR_IO_PENDING ? result : read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
   }
-  EXPECT_EQ(kStreamSize, stream.position());
-  ASSERT_TRUE(stream.IsEOF());
-}
-
-TEST_F(UploadDataStreamTest, Chunk) {
-  const uint64 kStreamSize = kTestDataSize*2;
-  UploadDataStream stream(UploadDataStream::CHUNKED, 0);
-  stream.AppendChunk(kTestData, kTestDataSize, false);
-  stream.AppendChunk(kTestData, kTestDataSize, true);
-
-  ASSERT_EQ(OK, stream.Init(CompletionCallback()));
-  EXPECT_FALSE(stream.IsInMemory());
-  EXPECT_EQ(0U, stream.size());  // Content-Length is 0 for chunked data.
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_FALSE(stream.IsEOF());
-  scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
-  while (!stream.IsEOF()) {
-    int bytes_read =
-        stream.Read(buf.get(), kTestBufferSize, CompletionCallback());
-    ASSERT_LE(0, bytes_read);  // Not an error.
-  }
-  EXPECT_EQ(kStreamSize, stream.position());
-  ASSERT_TRUE(stream.IsEOF());
+  EXPECT_EQ(kStreamSize, stream->position());
+  ASSERT_TRUE(stream->IsEOF());
 }
 
 // Init() with on-memory and not-on-memory readers.
-TEST_F(UploadDataStreamTest, InitAsync) {
+TEST_F(ElementsUploadDataStreamTest, InitAsync) {
   // Create UploadDataStream with mock readers.
   MockUploadElementReader* reader = NULL;
 
@@ -408,16 +395,17 @@
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(OK));
   element_readers_.push_back(reader);
 
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   // Run Init().
   TestCompletionCallback callback;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(callback.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(callback.callback()));
   EXPECT_EQ(OK, callback.WaitForResult());
 }
 
 // Init() of a reader fails asynchronously.
-TEST_F(UploadDataStreamTest, InitAsyncFailureAsync) {
+TEST_F(ElementsUploadDataStreamTest, InitAsyncFailureAsync) {
   // Create UploadDataStream with a mock reader.
   MockUploadElementReader* reader = NULL;
 
@@ -425,16 +413,17 @@
   reader->SetAsyncInitExpectation(ERR_FAILED);
   element_readers_.push_back(reader);
 
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   // Run Init().
   TestCompletionCallback callback;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(callback.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(callback.callback()));
   EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
 }
 
 // Init() of a reader fails synchronously.
-TEST_F(UploadDataStreamTest, InitAsyncFailureSync) {
+TEST_F(ElementsUploadDataStreamTest, InitAsyncFailureSync) {
   // Create UploadDataStream with mock readers.
   MockUploadElementReader* reader = NULL;
 
@@ -446,34 +435,36 @@
   EXPECT_CALL(*reader, Init(_)).WillOnce(Return(ERR_FAILED));
   element_readers_.push_back(reader);
 
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   // Run Init().
   TestCompletionCallback callback;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(callback.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(callback.callback()));
   EXPECT_EQ(ERR_FAILED, callback.WaitForResult());
 }
 
 // Read with a buffer whose size is same as the data.
-TEST_F(UploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
+TEST_F(ElementsUploadDataStreamTest, ReadAsyncWithExactSizeBuffer) {
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
-  ASSERT_EQ(OK, stream.Init(CompletionCallback()));
-  EXPECT_TRUE(stream.IsInMemory());
-  EXPECT_EQ(kTestDataSize, stream.size());
-  EXPECT_EQ(0U, stream.position());
-  EXPECT_FALSE(stream.IsEOF());
+  ASSERT_EQ(OK, stream->Init(CompletionCallback()));
+  EXPECT_TRUE(stream->IsInMemory());
+  EXPECT_EQ(kTestDataSize, stream->size());
+  EXPECT_EQ(0U, stream->position());
+  EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestDataSize);
-  int bytes_read = stream.Read(buf.get(), kTestDataSize, CompletionCallback());
+  int bytes_read = stream->Read(buf.get(), kTestDataSize, CompletionCallback());
   ASSERT_EQ(static_cast<int>(kTestDataSize), bytes_read);  // Not an error.
-  EXPECT_EQ(kTestDataSize, stream.position());
-  ASSERT_TRUE(stream.IsEOF());
+  EXPECT_EQ(kTestDataSize, stream->position());
+  ASSERT_TRUE(stream->IsEOF());
 }
 
 // Async Read() with on-memory and not-on-memory readers.
-TEST_F(UploadDataStreamTest, ReadAsync) {
+TEST_F(ElementsUploadDataStreamTest, ReadAsync) {
   // Create UploadDataStream with mock readers.
   MockUploadElementReader* reader = NULL;
 
@@ -497,11 +488,12 @@
   reader->SetReadExpectation(kTestDataSize);
   element_readers_.push_back(reader);
 
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   // Run Init().
   TestCompletionCallback init_callback;
-  EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   EXPECT_EQ(OK, init_callback.WaitForResult());
 
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
@@ -509,28 +501,29 @@
   // Consume the first element.
   TestCompletionCallback read_callback1;
   EXPECT_EQ(static_cast<int>(kTestDataSize),
-            stream.Read(buf.get(), kTestDataSize, read_callback1.callback()));
+            stream->Read(buf.get(), kTestDataSize, read_callback1.callback()));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FALSE(read_callback1.have_result());
 
   // Consume the second element.
   TestCompletionCallback read_callback2;
   ASSERT_EQ(ERR_IO_PENDING,
-            stream.Read(buf.get(), kTestDataSize, read_callback2.callback()));
+            stream->Read(buf.get(), kTestDataSize, read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(kTestDataSize), read_callback2.WaitForResult());
 
   // Consume the third and the fourth elements.
   TestCompletionCallback read_callback3;
   ASSERT_EQ(
       ERR_IO_PENDING,
-      stream.Read(buf.get(), kTestDataSize * 2, read_callback3.callback()));
+      stream->Read(buf.get(), kTestDataSize * 2, read_callback3.callback()));
   EXPECT_EQ(static_cast<int>(kTestDataSize * 2),
             read_callback3.WaitForResult());
 }
 
-void UploadDataStreamTest::FileChangedHelper(const base::FilePath& file_path,
-                                             const base::Time& time,
-                                             bool error_expected) {
+void ElementsUploadDataStreamTest::FileChangedHelper(
+    const base::FilePath& file_path,
+    const base::Time& time,
+    bool error_expected) {
   // Don't use element_readers_ here, as this function is called twice, and
   // reusing element_readers_ is wrong.
   ScopedVector<UploadElementReader> element_readers;
@@ -538,8 +531,9 @@
       base::MessageLoopProxy::current().get(), file_path, 1, 2, time));
 
   TestCompletionCallback init_callback;
-  UploadDataStream stream(element_readers.Pass(), 0);
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback.callback()));
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers.Pass(), 0));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   int error_code = init_callback.WaitForResult();
   if (error_expected)
     ASSERT_EQ(ERR_UPLOAD_FILE_CHANGED, error_code);
@@ -547,7 +541,7 @@
     ASSERT_EQ(OK, error_code);
 }
 
-TEST_F(UploadDataStreamTest, FileChanged) {
+TEST_F(ElementsUploadDataStreamTest, FileChanged) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -566,7 +560,7 @@
                     true);
 }
 
-TEST_F(UploadDataStreamTest, MultipleInit) {
+TEST_F(ElementsUploadDataStreamTest, MultipleInit) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -582,35 +576,36 @@
                                   0,
                                   kuint64max,
                                   base::Time()));
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
 
   // Call Init().
   TestCompletionCallback init_callback1;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback1.callback()));
   ASSERT_EQ(OK, init_callback1.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Read.
-  EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
-  EXPECT_TRUE(stream.IsEOF());
+  EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get()));
+  EXPECT_TRUE(stream->IsEOF());
 
   // Call Init() again to reset.
   TestCompletionCallback init_callback2;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback2.callback()));
   ASSERT_EQ(OK, init_callback2.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Read again.
-  EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
-  EXPECT_TRUE(stream.IsEOF());
+  EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get()));
+  EXPECT_TRUE(stream->IsEOF());
 }
 
-TEST_F(UploadDataStreamTest, MultipleInitAsync) {
+TEST_F(ElementsUploadDataStreamTest, MultipleInitAsync) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -627,33 +622,34 @@
                                   0,
                                   kuint64max,
                                   base::Time()));
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   std::string expected_data(kTestData, kTestData + kTestDataSize);
   expected_data += expected_data;
 
   // Call Init().
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(test_callback.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(test_callback.callback()));
   EXPECT_EQ(OK, test_callback.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Read.
-  EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
-  EXPECT_TRUE(stream.IsEOF());
+  EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get()));
+  EXPECT_TRUE(stream->IsEOF());
 
   // Call Init() again to reset.
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(test_callback.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(test_callback.callback()));
   EXPECT_EQ(OK, test_callback.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Read again.
-  EXPECT_EQ(expected_data, ReadFromUploadDataStream(&stream));
-  EXPECT_TRUE(stream.IsEOF());
+  EXPECT_EQ(expected_data, ReadFromUploadDataStream(stream.get()));
+  EXPECT_TRUE(stream->IsEOF());
 }
 
-TEST_F(UploadDataStreamTest, InitToReset) {
+TEST_F(ElementsUploadDataStreamTest, InitToReset) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -669,7 +665,8 @@
                                   0,
                                   kuint64max,
                                   base::Time()));
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
@@ -677,10 +674,10 @@
 
   // Call Init().
   TestCompletionCallback init_callback1;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Read some.
   TestCompletionCallback read_callback1;
@@ -688,29 +685,30 @@
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   EXPECT_EQ(
       ERR_IO_PENDING,
-      stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
+      stream->Read(wrapped_buffer.get(), buf.size(),
+                   read_callback1.callback()));
   EXPECT_EQ(static_cast<int>(buf.size()), read_callback1.WaitForResult());
-  EXPECT_EQ(buf.size(), stream.position());
+  EXPECT_EQ(buf.size(), stream->position());
 
   // Call Init to reset the state.
   TestCompletionCallback init_callback2;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Read.
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
   EXPECT_EQ(ERR_IO_PENDING,
-            stream.Read(
+            stream->Read(
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
 }
 
-TEST_F(UploadDataStreamTest, InitDuringAsyncInit) {
+TEST_F(ElementsUploadDataStreamTest, InitDuringAsyncInit) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -726,7 +724,8 @@
                                   0,
                                   kuint64max,
                                   base::Time()));
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
@@ -734,31 +733,31 @@
 
   // Start Init.
   TestCompletionCallback init_callback1;
-  EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, stream->Init(init_callback1.callback()));
 
   // Call Init again to cancel the previous init.
   TestCompletionCallback init_callback2;
-  EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, stream->Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Read.
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
   EXPECT_EQ(ERR_IO_PENDING,
-            stream.Read(
+            stream->Read(
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
-  EXPECT_TRUE(stream.IsEOF());
+  EXPECT_TRUE(stream->IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(init_callback1.have_result());
 }
 
-TEST_F(UploadDataStreamTest, InitDuringAsyncRead) {
+TEST_F(ElementsUploadDataStreamTest, InitDuringAsyncRead) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
@@ -774,7 +773,8 @@
                                   0,
                                   kuint64max,
                                   base::Time()));
-  UploadDataStream stream(element_readers_.Pass(), 0);
+  scoped_ptr<UploadDataStream> stream(
+      new ElementsUploadDataStream(element_readers_.Pass(), 0));
 
   std::vector<char> expected_data(kTestData, kTestData + kTestDataSize);
   expected_data.insert(expected_data.end(), expected_data.begin(),
@@ -782,10 +782,10 @@
 
   // Call Init().
   TestCompletionCallback init_callback1;
-  ASSERT_EQ(ERR_IO_PENDING, stream.Init(init_callback1.callback()));
+  ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback1.callback()));
   EXPECT_EQ(OK, init_callback1.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Start reading.
   TestCompletionCallback read_callback1;
@@ -793,25 +793,26 @@
   scoped_refptr<IOBuffer> wrapped_buffer = new WrappedIOBuffer(&buf[0]);
   EXPECT_EQ(
       ERR_IO_PENDING,
-      stream.Read(wrapped_buffer.get(), buf.size(), read_callback1.callback()));
+      stream->Read(wrapped_buffer.get(), buf.size(),
+                   read_callback1.callback()));
 
   // Call Init to cancel the previous read.
   TestCompletionCallback init_callback2;
-  EXPECT_EQ(ERR_IO_PENDING, stream.Init(init_callback2.callback()));
+  EXPECT_EQ(ERR_IO_PENDING, stream->Init(init_callback2.callback()));
   EXPECT_EQ(OK, init_callback2.WaitForResult());
-  EXPECT_FALSE(stream.IsEOF());
-  EXPECT_EQ(kTestDataSize*2, stream.size());
+  EXPECT_FALSE(stream->IsEOF());
+  EXPECT_EQ(kTestDataSize*2, stream->size());
 
   // Read.
   TestCompletionCallback read_callback2;
   std::vector<char> buf2(kTestDataSize*2);
   scoped_refptr<IOBuffer> wrapped_buffer2 = new WrappedIOBuffer(&buf2[0]);
   EXPECT_EQ(ERR_IO_PENDING,
-            stream.Read(
+            stream->Read(
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
-  EXPECT_TRUE(stream.IsEOF());
+  EXPECT_TRUE(stream->IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(read_callback1.have_result());
diff --git a/net/base/escape.cc b/net/base/escape.cc
index ab70f1d..7ce21a1 100644
--- a/net/base/escape.cc
+++ b/net/base/escape.cc
@@ -114,7 +114,7 @@
       static_cast<typename STR::value_type>(escaped_text[index + 2]));
   if (IsHexDigit(most_sig_digit) && IsHexDigit(least_sig_digit)) {
     *value = HexDigitToInt(most_sig_digit) * 16 +
-      HexDigitToInt(least_sig_digit);
+        HexDigitToInt(least_sig_digit);
     return true;
   }
   return false;
diff --git a/net/base/file_stream_context.h b/net/base/file_stream_context.h
index 74f47c4..5493e25 100644
--- a/net/base/file_stream_context.h
+++ b/net/base/file_stream_context.h
@@ -158,7 +158,7 @@
   // Implementation of MessageLoopForIO::IOHandler.
   virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                              DWORD bytes_read,
-                             DWORD error) OVERRIDE;
+                             DWORD error) override;
 #elif defined(OS_POSIX)
   // ReadFileImpl() is a simple wrapper around read() that handles EINTR
   // signals and calls RecordAndMapError() to map errno to net error codes.
diff --git a/net/base/keygen_handler_unittest.cc b/net/base/keygen_handler_unittest.cc
index 2962330..af4e01d 100644
--- a/net/base/keygen_handler_unittest.cc
+++ b/net/base/keygen_handler_unittest.cc
@@ -34,11 +34,11 @@
 
    virtual std::string RequestPassword(const std::string& slot_name,
                                        bool retry,
-                                       bool* cancelled) OVERRIDE{
+                                       bool* cancelled) override{
      return std::string();
    }
 
-   virtual crypto::ScopedPK11Slot RequestSlot() OVERRIDE {
+   virtual crypto::ScopedPK11Slot RequestSlot() override {
      return crypto::ScopedPK11Slot(PK11_ReferenceSlot(slot_.get()));
    }
 
diff --git a/net/base/mock_file_stream.h b/net/base/mock_file_stream.h
index 55261b4..abceb1b 100644
--- a/net/base/mock_file_stream.h
+++ b/net/base/mock_file_stream.h
@@ -29,14 +29,14 @@
 
   // FileStream methods.
   virtual int Seek(base::File::Whence whence, int64 offset,
-                   const Int64CompletionCallback& callback) OVERRIDE;
+                   const Int64CompletionCallback& callback) override;
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int Flush(const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int Flush(const CompletionCallback& callback) override;
 
   void set_forced_error_async(int error) {
     forced_error_ = error;
diff --git a/net/base/net_error_list.h b/net/base/net_error_list.h
index b805dd6..ae2ff13 100644
--- a/net/base/net_error_list.h
+++ b/net/base/net_error_list.h
@@ -336,6 +336,10 @@
 // library.
 NET_ERROR(SSL_CLIENT_AUTH_CERT_BAD_FORMAT, -164)
 
+// The SSL server requires falling back to a version older than the configured
+// minimum fallback version, and thus fallback failed.
+NET_ERROR(SSL_FALLBACK_BEYOND_MINIMUM_VERSION, -165)
+
 // Certificate error codes
 //
 // The values of certificate error codes must be consecutive.
diff --git a/net/base/net_log_logger.h b/net/base/net_log_logger.h
index fde820b..6604b82 100644
--- a/net/base/net_log_logger.h
+++ b/net/base/net_log_logger.h
@@ -41,7 +41,7 @@
   void StopObserving();
 
   // net::NetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE;
+  virtual void OnAddEntry(const NetLog::Entry& entry) override;
 
   // Create a dictionary containing legend for net/ constants.  Caller takes
   // ownership of returned value.
diff --git a/net/base/net_log_unittest.cc b/net/base/net_log_unittest.cc
index 8f15e9c..d1e7dde 100644
--- a/net/base/net_log_unittest.cc
+++ b/net/base/net_log_unittest.cc
@@ -80,7 +80,7 @@
       net_log()->RemoveThreadSafeObserver(this);
   }
 
-  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE {
+  virtual void OnAddEntry(const NetLog::Entry& entry) override {
     ++count_;
   }
 
@@ -99,7 +99,7 @@
       net_log()->RemoveThreadSafeObserver(this);
   }
 
-  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE {
+  virtual void OnAddEntry(const NetLog::Entry& entry) override {
     base::Value* value = entry.ToValue();
     base::DictionaryValue* dict = NULL;
     ASSERT_TRUE(value->GetAsDictionary(&dict));
@@ -138,7 +138,7 @@
     net_log_ = net_log;
   }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     start_event_->Wait();
     RunTestThread();
   }
@@ -165,7 +165,7 @@
   virtual ~AddEventsTestThread() {}
 
  private:
-  virtual void RunTestThread() OVERRIDE {
+  virtual void RunTestThread() override {
     for (int i = 0; i < kEvents; ++i)
       AddEvent(net_log_);
   }
@@ -183,7 +183,7 @@
   }
 
  private:
-  virtual void RunTestThread() OVERRIDE {
+  virtual void RunTestThread() override {
     for (int i = 0; i < kEvents; ++i) {
       ASSERT_FALSE(observer_.net_log());
 
diff --git a/net/base/net_util_icu.cc b/net/base/net_util_icu.cc
index 4094fee..bd5625b 100644
--- a/net/base/net_util_icu.cc
+++ b/net/base/net_util_icu.cc
@@ -493,7 +493,7 @@
  private:
   virtual base::string16 Execute(
       const std::string& component_text,
-      base::OffsetAdjuster::Adjustments* adjustments) const OVERRIDE {
+      base::OffsetAdjuster::Adjustments* adjustments) const override {
     return IDNToUnicodeWithAdjustments(component_text, languages_,
                                        adjustments);
   }
@@ -510,7 +510,7 @@
  private:
   virtual base::string16 Execute(
       const std::string& component_text,
-      base::OffsetAdjuster::Adjustments* adjustments) const OVERRIDE {
+      base::OffsetAdjuster::Adjustments* adjustments) const override {
     return (unescape_rules_ == UnescapeRule::NONE) ?
         base::UTF8ToUTF16WithAdjustments(component_text, adjustments) :
         UnescapeAndDecodeUTF8URLComponentWithAdjustments(component_text,
diff --git a/net/base/network_change_notifier.cc b/net/base/network_change_notifier.cc
index ef9e252..bea6759 100644
--- a/net/base/network_change_notifier.cc
+++ b/net/base/network_change_notifier.cc
@@ -45,7 +45,7 @@
 
 class MockNetworkChangeNotifier : public NetworkChangeNotifier {
  public:
-  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
+  virtual ConnectionType GetCurrentConnectionType() const override {
     return CONNECTION_UNKNOWN;
   }
 };
@@ -93,7 +93,7 @@
   }
 
   // NetworkChangeNotifier::IPAddressObserver implementation.
-  virtual void OnIPAddressChanged() OVERRIDE {
+  virtual void OnIPAddressChanged() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.IPAddressChange",
                                SinceLast(&last_ip_address_change_));
@@ -104,7 +104,7 @@
 
   // NetworkChangeNotifier::ConnectionTypeObserver implementation.
   virtual void OnConnectionTypeChanged(
-      NetworkChangeNotifier::ConnectionType type) OVERRIDE {
+      NetworkChangeNotifier::ConnectionType type) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     base::TimeTicks now = base::TimeTicks::Now();
     int32 kilobytes_read = bytes_read_since_last_connection_change_ / 1000;
@@ -264,7 +264,7 @@
   }
 
   // NetworkChangeNotifier::DNSObserver implementation.
-  virtual void OnDNSChanged() OVERRIDE {
+  virtual void OnDNSChanged() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     UMA_HISTOGRAM_MEDIUM_TIMES("NCN.DNSConfigChange",
                                SinceLast(&last_dns_change_));
@@ -272,7 +272,7 @@
 
   // NetworkChangeNotifier::NetworkChangeObserver implementation.
   virtual void OnNetworkChanged(
-      NetworkChangeNotifier::ConnectionType type) OVERRIDE {
+      NetworkChangeNotifier::ConnectionType type) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (type != NetworkChangeNotifier::CONNECTION_NONE) {
       UMA_HISTOGRAM_MEDIUM_TIMES("NCN.NetworkOnlineChange",
@@ -432,7 +432,7 @@
   }
 
   // NetworkChangeNotifier::IPAddressObserver implementation.
-  virtual void OnIPAddressChanged() OVERRIDE {
+  virtual void OnIPAddressChanged() override {
     DCHECK(thread_checker_.CalledOnValidThread());
     base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
         ? params_.ip_address_offline_delay_ : params_.ip_address_online_delay_;
@@ -441,7 +441,7 @@
   }
 
   // NetworkChangeNotifier::ConnectionTypeObserver implementation.
-  virtual void OnConnectionTypeChanged(ConnectionType type) OVERRIDE {
+  virtual void OnConnectionTypeChanged(ConnectionType type) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     pending_connection_type_ = type;
     base::TimeDelta delay = last_announced_connection_type_ == CONNECTION_NONE
diff --git a/net/base/network_change_notifier_linux.cc b/net/base/network_change_notifier_linux.cc
index 3fe9656..b10f8a8 100644
--- a/net/base/network_change_notifier_linux.cc
+++ b/net/base/network_change_notifier_linux.cc
@@ -29,8 +29,8 @@
 
  protected:
   // base::Thread
-  virtual void Init() OVERRIDE;
-  virtual void CleanUp() OVERRIDE;
+  virtual void Init() override;
+  virtual void CleanUp() override;
 
  private:
   scoped_ptr<DnsConfigService> dns_config_service_;
diff --git a/net/base/network_change_notifier_linux.h b/net/base/network_change_notifier_linux.h
index a7080d9..1e8a7eb 100644
--- a/net/base/network_change_notifier_linux.h
+++ b/net/base/network_change_notifier_linux.h
@@ -26,10 +26,10 @@
   static NetworkChangeCalculatorParams NetworkChangeCalculatorParamsLinux();
 
   // NetworkChangeNotifier:
-  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE;
+  virtual ConnectionType GetCurrentConnectionType() const override;
 
   virtual const internal::AddressTrackerLinux*
-      GetAddressTrackerInternal() const OVERRIDE;
+      GetAddressTrackerInternal() const override;
 
   // The thread used to listen for notifications.  This relays the notification
   // to the registered observers without posting back to the thread the object
diff --git a/net/base/network_change_notifier_mac.cc b/net/base/network_change_notifier_mac.cc
index 7fa97b4..e378418 100644
--- a/net/base/network_change_notifier_mac.cc
+++ b/net/base/network_change_notifier_mac.cc
@@ -47,12 +47,12 @@
     Stop();
   }
 
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     service_ = DnsConfigService::CreateSystemService();
     service_->WatchConfig(base::Bind(&NetworkChangeNotifier::SetDnsConfig));
   }
 
-  virtual void CleanUp() OVERRIDE {
+  virtual void CleanUp() override {
     service_.reset();
   }
 
diff --git a/net/base/network_change_notifier_mac.h b/net/base/network_change_notifier_mac.h
index 168ea14..1598c4c 100644
--- a/net/base/network_change_notifier_mac.h
+++ b/net/base/network_change_notifier_mac.h
@@ -24,7 +24,7 @@
   virtual ~NetworkChangeNotifierMac();
 
   // NetworkChangeNotifier implementation:
-  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE;
+  virtual ConnectionType GetCurrentConnectionType() const override;
 
   // Forwarder just exists to keep the NetworkConfigWatcherMac API out of
   // NetworkChangeNotifierMac's public API.
@@ -34,11 +34,11 @@
         : net_config_watcher_(net_config_watcher) {}
 
     // NetworkConfigWatcherMac::Delegate implementation:
-    virtual void Init() OVERRIDE;
-    virtual void StartReachabilityNotifications() OVERRIDE;
+    virtual void Init() override;
+    virtual void StartReachabilityNotifications() override;
     virtual void SetDynamicStoreNotificationKeys(
-        SCDynamicStoreRef store) OVERRIDE;
-    virtual void OnNetworkConfigChange(CFArrayRef changed_keys) OVERRIDE;
+        SCDynamicStoreRef store) override;
+    virtual void OnNetworkConfigChange(CFArrayRef changed_keys) override;
 
    private:
     NetworkChangeNotifierMac* const net_config_watcher_;
diff --git a/net/base/network_change_notifier_win.cc b/net/base/network_change_notifier_win.cc
index 4580fa8..2255681 100644
--- a/net/base/network_change_notifier_win.cc
+++ b/net/base/network_change_notifier_win.cc
@@ -37,12 +37,12 @@
     Stop();
   }
 
-  virtual void Init() OVERRIDE {
+  virtual void Init() override {
     service_ = DnsConfigService::CreateSystemService();
     service_->WatchConfig(base::Bind(&NetworkChangeNotifier::SetDnsConfig));
   }
 
-  virtual void CleanUp() OVERRIDE {
+  virtual void CleanUp() override {
     service_.reset();
   }
 
diff --git a/net/base/network_change_notifier_win.h b/net/base/network_change_notifier_win.h
index 4ded749..9de1789 100644
--- a/net/base/network_change_notifier_win.h
+++ b/net/base/network_change_notifier_win.h
@@ -51,11 +51,11 @@
   friend class NetworkChangeNotifierWinTest;
 
   // NetworkChangeNotifier methods:
-  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE;
+  virtual ConnectionType GetCurrentConnectionType() const override;
 
   // ObjectWatcher::Delegate methods:
   // Must only be called on the thread |this| was created on.
-  virtual void OnObjectSignaled(HANDLE object) OVERRIDE;
+  virtual void OnObjectSignaled(HANDLE object) override;
 
   // Does the actual work to determine the current connection type.
   // It is not thread safe, see crbug.com/324913.
diff --git a/net/base/network_change_notifier_win_unittest.cc b/net/base/network_change_notifier_win_unittest.cc
index 979105f..25873c3 100644
--- a/net/base/network_change_notifier_win_unittest.cc
+++ b/net/base/network_change_notifier_win_unittest.cc
@@ -32,7 +32,7 @@
 
   // From NetworkChangeNotifierWin.
   virtual NetworkChangeNotifier::ConnectionType
-      RecomputeCurrentConnectionType() const OVERRIDE {
+      RecomputeCurrentConnectionType() const override {
     return NetworkChangeNotifier::CONNECTION_UNKNOWN;
   }
 
diff --git a/net/base/network_config_watcher_mac.cc b/net/base/network_config_watcher_mac.cc
index 8579a35..7d2377c 100644
--- a/net/base/network_config_watcher_mac.cc
+++ b/net/base/network_config_watcher_mac.cc
@@ -35,8 +35,8 @@
 
  protected:
   // base::Thread
-  virtual void Init() OVERRIDE;
-  virtual void CleanUp() OVERRIDE;
+  virtual void Init() override;
+  virtual void CleanUp() override;
 
  private:
   // The SystemConfiguration calls in this function can lead to contention early
diff --git a/net/base/prioritized_dispatcher_unittest.cc b/net/base/prioritized_dispatcher_unittest.cc
index 3036038..4cdf53b 100644
--- a/net/base/prioritized_dispatcher_unittest.cc
+++ b/net/base/prioritized_dispatcher_unittest.cc
@@ -117,7 +117,7 @@
     }
 
     // PriorityDispatch::Job interface
-    virtual void Start() OVERRIDE {
+    virtual void Start() override {
       EXPECT_FALSE(running_);
       handle_ = PrioritizedDispatcher::Handle();
       running_ = true;
diff --git a/net/base/priority_queue_unittest.cc b/net/base/priority_queue_unittest.cc
index 8093319..87a8299 100644
--- a/net/base/priority_queue_unittest.cc
+++ b/net/base/priority_queue_unittest.cc
@@ -25,7 +25,7 @@
  protected:
   PriorityQueueTest() : queue_(kNumPriorities) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     CheckEmpty();
     for (size_t i = 0; i < kNumElements; ++i) {
       EXPECT_EQ(i, queue_.size());
diff --git a/net/base/sdch_dictionary_fetcher.h b/net/base/sdch_dictionary_fetcher.h
index f70d56a..86aaf48 100644
--- a/net/base/sdch_dictionary_fetcher.h
+++ b/net/base/sdch_dictionary_fetcher.h
@@ -44,12 +44,12 @@
   virtual ~SdchDictionaryFetcher();
 
   // Implementation of SdchFetcher methods.
-  virtual void Schedule(const GURL& dictionary_url) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
+  virtual void Schedule(const GURL& dictionary_url) override;
+  virtual void Cancel() override;
 
   // Implementation of URLRequest::Delegate methods.
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read) OVERRIDE;
+  virtual void OnResponseStarted(URLRequest* request) override;
+  virtual void OnReadCompleted(URLRequest* request, int bytes_read) override;
 
  private:
   enum State {
diff --git a/net/base/sdch_dictionary_fetcher_unittest.cc b/net/base/sdch_dictionary_fetcher_unittest.cc
index 09155b8..a8b3040 100644
--- a/net/base/sdch_dictionary_fetcher_unittest.cc
+++ b/net/base/sdch_dictionary_fetcher_unittest.cc
@@ -62,7 +62,7 @@
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
-                      const CompletionCallback& callback) const OVERRIDE {
+                      const CompletionCallback& callback) const override {
     GURL url(request_->url());
     *data = ExpectedResponseForURL(url);
     return OK;
@@ -87,7 +87,7 @@
   };
 
   virtual void AddSdchDictionary(const std::string& dictionary_text,
-                                 const GURL& dictionary_url) OVERRIDE {
+                                 const GURL& dictionary_url) override {
     dictionary_additions.push_back(
         DictionaryAdditions(dictionary_text, dictionary_url));
   }
@@ -105,7 +105,7 @@
  public:
   SdchDictionaryFetcherTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     DCHECK(!fetcher_.get());
 
     URLRequestSpecifiedResponseJob::AddUrlHandler();
@@ -115,7 +115,7 @@
         fetcher_delegate_.get(), context_.get()));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     URLRequestSpecifiedResponseJob::RemoveUrlHandler();
     fetcher_.reset();
     context_.reset();
diff --git a/net/base/sdch_manager.h b/net/base/sdch_manager.h
index 7d2c103..18f6749 100644
--- a/net/base/sdch_manager.h
+++ b/net/base/sdch_manager.h
@@ -356,7 +356,7 @@
   // (data in the dictionary is not acceptable from the
   // dictionary_url; dictionary already added, etc.).
   virtual void AddSdchDictionary(const std::string& dictionary_text,
-                                 const GURL& dictionary_url) OVERRIDE;
+                                 const GURL& dictionary_url) override;
 
  private:
   struct BlacklistInfo {
diff --git a/net/base/test_completion_callback.h b/net/base/test_completion_callback.h
index 4a0afe1..469d12f 100644
--- a/net/base/test_completion_callback.h
+++ b/net/base/test_completion_callback.h
@@ -117,7 +117,7 @@
   virtual ~ReleaseBufferCompletionCallback();
 
  private:
-  virtual void SetResult(int result) OVERRIDE;
+  virtual void SetResult(int result) override;
 
   IOBuffer* buffer_;
   DISALLOW_COPY_AND_ASSIGN(ReleaseBufferCompletionCallback);
diff --git a/net/base/trace_net_log_observer.cc b/net/base/trace_net_log_observer.cc
index fb4f054..77945fb 100644
--- a/net/base/trace_net_log_observer.cc
+++ b/net/base/trace_net_log_observer.cc
@@ -26,7 +26,7 @@
  private:
   virtual ~TracedValue() {}
 
-  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+  virtual void AppendAsTraceFormat(std::string* out) const override {
     if (value_) {
       std::string tmp;
       base::JSONWriter::Write(value_.get(), &tmp);
diff --git a/net/base/trace_net_log_observer.h b/net/base/trace_net_log_observer.h
index ed46fdb..567ba3f 100644
--- a/net/base/trace_net_log_observer.h
+++ b/net/base/trace_net_log_observer.h
@@ -22,7 +22,7 @@
   virtual ~TraceNetLogObserver();
 
   // net::NetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(const NetLog::Entry& entry) OVERRIDE;
+  virtual void OnAddEntry(const NetLog::Entry& entry) override;
 
   // Start to watch for TraceLog enable and disable events.
   // This can't be called if already watching for events.
@@ -35,8 +35,8 @@
   void StopWatchForTraceStart();
 
   // base::debug::TraceLog::EnabledStateChangedObserver implementation:
-  virtual void OnTraceLogEnabled() OVERRIDE;
-  virtual void OnTraceLogDisabled() OVERRIDE;
+  virtual void OnTraceLogEnabled() override;
+  virtual void OnTraceLogDisabled() override;
 
  private:
   NetLog* net_log_to_watch_;
diff --git a/net/base/upload_bytes_element_reader.h b/net/base/upload_bytes_element_reader.h
index 9c7daf3..589e287 100644
--- a/net/base/upload_bytes_element_reader.h
+++ b/net/base/upload_bytes_element_reader.h
@@ -26,14 +26,14 @@
   uint64 length() const { return length_; }
 
   // UploadElementReader overrides:
-  virtual const UploadBytesElementReader* AsBytesReader() const OVERRIDE;
-  virtual int Init(const CompletionCallback& callback) OVERRIDE;
-  virtual uint64 GetContentLength() const OVERRIDE;
-  virtual uint64 BytesRemaining() const OVERRIDE;
-  virtual bool IsInMemory() const OVERRIDE;
+  virtual const UploadBytesElementReader* AsBytesReader() const override;
+  virtual int Init(const CompletionCallback& callback) override;
+  virtual uint64 GetContentLength() const override;
+  virtual uint64 BytesRemaining() const override;
+  virtual bool IsInMemory() const override;
   virtual int Read(IOBuffer* buf,
                    int buf_length,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
 
  private:
   const char* const bytes_;
diff --git a/net/base/upload_bytes_element_reader_unittest.cc b/net/base/upload_bytes_element_reader_unittest.cc
index 1aad55e..e15bbcf 100644
--- a/net/base/upload_bytes_element_reader_unittest.cc
+++ b/net/base/upload_bytes_element_reader_unittest.cc
@@ -15,7 +15,7 @@
 
 class UploadBytesElementReaderTest : public PlatformTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     const char kData[] = "123abc";
     bytes_.assign(kData, kData + arraysize(kData));
     reader_.reset(new UploadBytesElementReader(&bytes_[0], bytes_.size()));
diff --git a/net/base/upload_data_stream.cc b/net/base/upload_data_stream.cc
index 785d5e9..936c912 100644
--- a/net/base/upload_data_stream.cc
+++ b/net/base/upload_data_stream.cc
@@ -4,261 +4,125 @@
 
 #include "net/base/upload_data_stream.h"
 
+#include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
-#include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_element_reader.h"
 
 namespace net {
 
-UploadDataStream::UploadDataStream(
-    ScopedVector<UploadElementReader> element_readers,
-    int64 identifier)
-    : element_readers_(element_readers.Pass()),
-      element_index_(0),
-      total_size_(0),
+UploadDataStream::UploadDataStream(bool is_chunked, int64 identifier)
+    : total_size_(0),
       current_position_(0),
       identifier_(identifier),
-      is_chunked_(false),
-      last_chunk_appended_(false),
-      read_failed_(false),
+      is_chunked_(is_chunked),
       initialized_successfully_(false),
-      weak_ptr_factory_(this) {
-}
-
-UploadDataStream::UploadDataStream(Chunked /*chunked*/, int64 identifier)
-    : element_index_(0),
-      total_size_(0),
-      current_position_(0),
-      identifier_(identifier),
-      is_chunked_(true),
-      last_chunk_appended_(false),
-      read_failed_(false),
-      initialized_successfully_(false),
-      weak_ptr_factory_(this) {
+      is_eof_(false) {
 }
 
 UploadDataStream::~UploadDataStream() {
 }
 
-UploadDataStream* UploadDataStream::CreateWithReader(
-    scoped_ptr<UploadElementReader> reader,
-    int64 identifier) {
-  ScopedVector<UploadElementReader> readers;
-  readers.push_back(reader.release());
-  return new UploadDataStream(readers.Pass(), identifier);
-}
-
 int UploadDataStream::Init(const CompletionCallback& callback) {
   Reset();
-  return InitInternal(0, callback);
+  DCHECK(!initialized_successfully_);
+  DCHECK(callback_.is_null());
+  DCHECK(!callback.is_null() || IsInMemory());
+  int result = InitInternal();
+  if (result == ERR_IO_PENDING) {
+    DCHECK(!IsInMemory());
+    callback_ = callback;
+  } else {
+    OnInitCompleted(result);
+  }
+  return result;
 }
 
 int UploadDataStream::Read(IOBuffer* buf,
                            int buf_len,
                            const CompletionCallback& callback) {
+  DCHECK(!callback.is_null() || IsInMemory());
   DCHECK(initialized_successfully_);
   DCHECK_GT(buf_len, 0);
-  return ReadInternal(new DrainableIOBuffer(buf, buf_len), callback);
+  if (is_eof_)
+    return 0;
+  int result = ReadInternal(buf, buf_len);
+  if (result == ERR_IO_PENDING) {
+    DCHECK(!IsInMemory());
+    callback_ = callback;
+  } else {
+    OnReadCompleted(result);
+  }
+  return result;
 }
 
 bool UploadDataStream::IsEOF() const {
   DCHECK(initialized_successfully_);
-  if (!is_chunked_)
-    return current_position_ == total_size_;
-
-  // If the upload data is chunked, check if the last chunk is appended and all
-  // elements are consumed.
-  return element_index_ == element_readers_.size() && last_chunk_appended_;
-}
-
-bool UploadDataStream::IsInMemory() const {
-  // Chunks are in memory, but UploadData does not have all the chunks at
-  // once. Chunks are provided progressively with AppendChunk() as chunks
-  // are ready. Check is_chunked_ here, rather than relying on the loop
-  // below, as there is a case that is_chunked_ is set to true, but the
-  // first chunk is not yet delivered.
-  if (is_chunked_)
-    return false;
-
-  for (size_t i = 0; i < element_readers_.size(); ++i) {
-    if (!element_readers_[i]->IsInMemory())
-      return false;
-  }
-  return true;
-}
-
-void UploadDataStream::AppendChunk(const char* bytes,
-                                   int bytes_len,
-                                   bool is_last_chunk) {
-  DCHECK(is_chunked_);
-  DCHECK(!last_chunk_appended_);
-  last_chunk_appended_ = is_last_chunk;
-
-  // Initialize a reader for the newly appended chunk. We leave |total_size_| at
-  // zero, since for chunked uploads, we may not know the total size.
-  std::vector<char> data(bytes, bytes + bytes_len);
-  UploadElementReader* reader = new UploadOwnedBytesElementReader(&data);
-  const int rv = reader->Init(net::CompletionCallback());
-  DCHECK_EQ(OK, rv);
-  element_readers_.push_back(reader);
-
-  // Resume pending read.
-  if (!pending_chunked_read_callback_.is_null()) {
-    base::Closure callback = pending_chunked_read_callback_;
-    pending_chunked_read_callback_.Reset();
-    callback.Run();
-  }
+  DCHECK(is_chunked_ || is_eof_ == (current_position_ == total_size_));
+  return is_eof_;
 }
 
 void UploadDataStream::Reset() {
-  weak_ptr_factory_.InvalidateWeakPtrs();
-  pending_chunked_read_callback_.Reset();
-  initialized_successfully_ = false;
-  read_failed_ = false;
   current_position_ = 0;
+  initialized_successfully_ = false;
+  is_eof_ = false;
   total_size_ = 0;
-  element_index_ = 0;
+  callback_.Reset();
+  ResetInternal();
 }
 
-int UploadDataStream::InitInternal(int start_index,
-                                   const CompletionCallback& callback) {
+void UploadDataStream::SetSize(uint64 size) {
   DCHECK(!initialized_successfully_);
-
-  // Call Init() for all elements.
-  for (size_t i = start_index; i < element_readers_.size(); ++i) {
-    UploadElementReader* reader = element_readers_[i];
-    // When new_result is ERR_IO_PENDING, InitInternal() will be called
-    // with start_index == i + 1 when reader->Init() finishes.
-    const int result = reader->Init(
-        base::Bind(&UploadDataStream::ResumePendingInit,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   i + 1,
-                   callback));
-    if (result != OK) {
-      DCHECK(result != ERR_IO_PENDING || !callback.is_null());
-      return result;
-    }
-  }
-
-  // Finalize initialization.
-  if (!is_chunked_) {
-    uint64 total_size = 0;
-    for (size_t i = 0; i < element_readers_.size(); ++i) {
-      UploadElementReader* reader = element_readers_[i];
-      total_size += reader->GetContentLength();
-    }
-    total_size_ = total_size;
-  }
-  initialized_successfully_ = true;
-  return OK;
+  DCHECK(!is_chunked_);
+  total_size_ = size;
 }
 
-void UploadDataStream::ResumePendingInit(int start_index,
-                                         const CompletionCallback& callback,
-                                         int previous_result) {
+void UploadDataStream::SetIsFinalChunk() {
+  DCHECK(initialized_successfully_);
+  DCHECK(is_chunked_);
+  DCHECK(!is_eof_);
+  is_eof_ = true;
+}
+
+bool UploadDataStream::IsInMemory() const {
+  return false;
+}
+
+const ScopedVector<UploadElementReader>*
+UploadDataStream::GetElementReaders() const {
+  return NULL;
+}
+
+void UploadDataStream::OnInitCompleted(int result) {
+  DCHECK_NE(ERR_IO_PENDING, result);
   DCHECK(!initialized_successfully_);
-  DCHECK(!callback.is_null());
-  DCHECK_NE(ERR_IO_PENDING, previous_result);
+  DCHECK_EQ(0u, current_position_);
+  DCHECK(!is_eof_);
 
-  // Check the last result.
-  if (previous_result != OK) {
-    callback.Run(previous_result);
-    return;
+  if (result == OK) {
+    initialized_successfully_ = true;
+    if (!is_chunked_ && total_size_ == 0)
+      is_eof_ = true;
   }
-
-  const int result = InitInternal(start_index, callback);
-  if (result != ERR_IO_PENDING)
-    callback.Run(result);
+  if (!callback_.is_null())
+    base::ResetAndReturn(&callback_).Run(result);
 }
 
-int UploadDataStream::ReadInternal(scoped_refptr<DrainableIOBuffer> buf,
-                                   const CompletionCallback& callback) {
+void UploadDataStream::OnReadCompleted(int result) {
+  DCHECK_GE(result, 0);
   DCHECK(initialized_successfully_);
 
-  while (!read_failed_ && element_index_ < element_readers_.size()) {
-    UploadElementReader* reader = element_readers_[element_index_];
-
-    if (reader->BytesRemaining() == 0) {
-      ++element_index_;
-      continue;
-    }
-
-    if (buf->BytesRemaining() == 0)
-      break;
-
-    int result = reader->Read(
-        buf.get(),
-        buf->BytesRemaining(),
-        base::Bind(base::IgnoreResult(&UploadDataStream::ResumePendingRead),
-                   weak_ptr_factory_.GetWeakPtr(),
-                   buf,
-                   callback));
-    if (result == ERR_IO_PENDING) {
-      DCHECK(!callback.is_null());
-      return ERR_IO_PENDING;
-    }
-    ProcessReadResult(buf, result);
+  current_position_ += result;
+  if (!is_chunked_) {
+    DCHECK_LE(current_position_, total_size_);
+    if (current_position_ == total_size_)
+      is_eof_ = true;
   }
 
-  if (read_failed_) {
-    // Chunked transfers may only contain byte readers, so cannot have read
-    // failures.
-    DCHECK(!is_chunked_);
+  DCHECK(result > 0 || is_eof_);
 
-    // If an error occured during read operation, then pad with zero.
-    // Otherwise the server will hang waiting for the rest of the data.
-    const int num_bytes_to_fill =
-        std::min(static_cast<uint64>(buf->BytesRemaining()),
-                 size() - position() - buf->BytesConsumed());
-    DCHECK_LE(0, num_bytes_to_fill);
-    memset(buf->data(), 0, num_bytes_to_fill);
-    buf->DidConsume(num_bytes_to_fill);
-  }
-
-  const int bytes_copied = buf->BytesConsumed();
-  current_position_ += bytes_copied;
-  DCHECK(is_chunked_ || total_size_ >= current_position_);
-
-  if (is_chunked_ && !IsEOF() && bytes_copied == 0) {
-    DCHECK(!callback.is_null());
-    DCHECK(pending_chunked_read_callback_.is_null());
-    pending_chunked_read_callback_ =
-        base::Bind(&UploadDataStream::ResumePendingRead,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   buf,
-                   callback,
-                   OK);
-    return ERR_IO_PENDING;
-  }
-
-  // Returning 0 is allowed only when IsEOF() == true.
-  DCHECK(bytes_copied != 0 || IsEOF());
-  return bytes_copied;
-}
-
-void UploadDataStream::ResumePendingRead(scoped_refptr<DrainableIOBuffer> buf,
-                                         const CompletionCallback& callback,
-                                         int previous_result) {
-  DCHECK(!callback.is_null());
-
-  ProcessReadResult(buf, previous_result);
-
-  const int result = ReadInternal(buf, callback);
-  if (result != ERR_IO_PENDING)
-    callback.Run(result);
-}
-
-void UploadDataStream::ProcessReadResult(scoped_refptr<DrainableIOBuffer> buf,
-                                         int result) {
-  DCHECK_NE(ERR_IO_PENDING, result);
-  DCHECK(!read_failed_);
-
-  if (result >= 0)
-    buf->DidConsume(result);
-  else
-    read_failed_ = true;
+  if (!callback_.is_null())
+    base::ResetAndReturn(&callback_).Run(result);
 }
 
 }  // namespace net
diff --git a/net/base/upload_data_stream.h b/net/base/upload_data_stream.h
index ac14e38..d7df8c9 100644
--- a/net/base/upload_data_stream.h
+++ b/net/base/upload_data_stream.h
@@ -5,10 +5,9 @@
 #ifndef NET_BASE_UPLOAD_DATA_STREAM_H_
 #define NET_BASE_UPLOAD_DATA_STREAM_H_
 
-#include "base/gtest_prod_util.h"
-#include "base/memory/ref_counted.h"
+#include "base/basictypes.h"
+#include "base/macros.h"
 #include "base/memory/scoped_vector.h"
-#include "base/memory/weak_ptr.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 
@@ -18,31 +17,22 @@
 class IOBuffer;
 class UploadElementReader;
 
-// A class to read all elements from an UploadData object.
+// A class for retrieving all data to be sent as a request body. Supports both
+// chunked and non-chunked uploads.
 class NET_EXPORT UploadDataStream {
  public:
-  // An enum used to construct chunked data stream.
-  enum Chunked { CHUNKED };
+  // |identifier| identifies a particular upload instance, which is used by the
+  // cache to formulate a cache key. This value should be unique across browser
+  // sessions. A value of 0 is used to indicate an unspecified identifier.
+  UploadDataStream(bool is_chunked, int64 identifier);
 
-  // Constructs a non-chunked data stream.
-  UploadDataStream(ScopedVector<UploadElementReader> element_readers,
-                   int64 identifier);
-
-  // Constructs a chunked data stream.
-  UploadDataStream(Chunked chunked, int64 identifier);
-
-  ~UploadDataStream();
-
-  // Creates UploadDataStream with a reader.
-  static UploadDataStream* CreateWithReader(
-      scoped_ptr<UploadElementReader> reader,
-      int64 identifier);
+  virtual ~UploadDataStream();
 
   // Initializes the stream. This function must be called before calling any
   // other method. It is not valid to call any method (other than the
-  // destructor) if Init() returns a failure. This method can be called multiple
-  // times. Calling this method after a Init() success results in resetting the
-  // state.
+  // destructor) if Init() fails. This method can be called multiple times.
+  // Calling this method after an Init() success results in resetting the
+  // state (i.e. the stream is rewound).
   //
   // Does the initialization synchronously and returns the result if possible,
   // otherwise returns ERR_IO_PENDING and runs the callback with the result.
@@ -62,93 +52,88 @@
   // If there's less data to read than we initially observed (i.e. the actual
   // upload data is smaller than size()), zeros are padded to ensure that
   // size() bytes can be read, which can happen for TYPE_FILE payloads.
+  //
+  // Reads are currently not allowed to fail - they must either return
+  // a value >= 0 or ERR_IO_PENDING, and call OnReadCompleted with a
+  // value >= 0.
+  // TODO(mmenke):  Investigate letting reads fail.
   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
 
-  // Identifies a particular upload instance, which is used by the cache to
-  // formulate a cache key.  This value should be unique across browser
-  // sessions.  A value of 0 is used to indicate an unspecified identifier.
-  int64 identifier() const { return identifier_; }
-
   // Returns the total size of the data stream and the current position.
-  // size() is not to be used to determine whether the stream has ended
-  // because it is possible for the stream to end before its size is reached,
-  // for example, if the file is truncated. When the data is chunked, size()
-  // always returns zero.
+  // When the data is chunked, always returns zero. Must always return the same
+  // value after each call to Initialize().
   uint64 size() const { return total_size_; }
   uint64 position() const { return current_position_; }
 
-  bool is_chunked() const { return is_chunked_; }
-  bool last_chunk_appended() const { return last_chunk_appended_; }
+  // See constructor for description.
+  int64 identifier() const { return identifier_; }
 
-  const ScopedVector<UploadElementReader>& element_readers() const {
-    return element_readers_;
-  }
+  bool is_chunked() const { return is_chunked_; }
 
   // Returns true if all data has been consumed from this upload data
-  // stream.
+  // stream. For chunked uploads, returns false until the first read attempt.
+  // This makes some state machines a little simpler.
   bool IsEOF() const;
 
-  // Returns true if the upload data in the stream is entirely in memory.
-  bool IsInMemory() const;
-
-  // Adds the given chunk of bytes to be sent with chunked transfer encoding.
-  void AppendChunk(const char* bytes, int bytes_len, bool is_last_chunk);
-
-  // Resets this instance to the uninitialized state.
+  // Cancels all pending callbacks, and resets state. Any IOBuffer currently
+  // being read to is not safe for future use, as it may be in use on another
+  // thread.
   void Reset();
 
+  // Returns true if the upload data in the stream is entirely in memory, and
+  // all read requests will succeed synchronously. Expected to return false for
+  // chunked requests.
+  virtual bool IsInMemory() const;
+
+  // Returns a list of element readers owned by |this|, if it has any.
+  virtual const ScopedVector<UploadElementReader>*
+      GetElementReaders() const;
+
+ protected:
+  // Must be called by subclasses when InitInternal and ReadInternal complete
+  // asynchronously.
+  void OnInitCompleted(int result);
+  void OnReadCompleted(int result);
+
+  // Must be called before InitInternal completes, for non-chunked uploads.
+  // Must not be called for chunked uploads.
+  void SetSize(uint64 size);
+
+  // Must be called for chunked uploads before the final ReadInternal call
+  // completes. Must not be called for non-chunked uploads.
+  void SetIsFinalChunk();
+
  private:
-  // Runs Init() for all element readers.
-  // This method is used to implement Init().
-  int InitInternal(int start_index, const CompletionCallback& callback);
+  // See Init(). If it returns ERR_IO_PENDING, OnInitCompleted must be called
+  // once it completes. If the upload is not chunked, SetSize must be called
+  // before it completes.
+  virtual int InitInternal() = 0;
 
-  // Resumes initialization and runs callback with the result when necessary.
-  void ResumePendingInit(int start_index,
-                         const CompletionCallback& callback,
-                         int previous_result);
+  // See Read(). For chunked uploads, must call SetIsFinalChunk if this is the
+  // final chunk. For non-chunked uploads, the UploadDataStream determins which
+  // read is the last based on size. Must read 1 or more bytes on every call,
+  // though the final chunk may be 0 bytes, for chunked requests. If it returns
+  // ERR_IO_PENDING, OnInitCompleted must be called once it completes. Must not
+  // return any error, other than ERR_IO_PENDING.
+  virtual int ReadInternal(IOBuffer* buf, int buf_len) = 0;
 
-  // Reads data from the element readers.
-  // This method is used to implement Read().
-  int ReadInternal(scoped_refptr<DrainableIOBuffer> buf,
-                   const CompletionCallback& callback);
+  // Resets state and cancels any pending callbacks. Guaranteed to be called
+  // before all but the first call to InitInternal.
+  virtual void ResetInternal() = 0;
 
-  // Resumes pending read and calls callback with the result when necessary.
-  void ResumePendingRead(scoped_refptr<DrainableIOBuffer> buf,
-                         const CompletionCallback& callback,
-                         int previous_result);
-
-  // Processes result of UploadElementReader::Read(). If |result| indicates
-  // success, updates |buf|'s offset. Otherwise, sets |read_failed_| to true.
-  void ProcessReadResult(scoped_refptr<DrainableIOBuffer> buf,
-                         int result);
-
-  ScopedVector<UploadElementReader> element_readers_;
-
-  // Index of the current upload element (i.e. the element currently being
-  // read). The index is used as a cursor to iterate over elements in
-  // |upload_data_|.
-  size_t element_index_;
-
-  // Size and current read position within the upload data stream.
-  // |total_size_| is set to zero when the data is chunked.
   uint64 total_size_;
   uint64 current_position_;
 
   const int64 identifier_;
 
   const bool is_chunked_;
-  bool last_chunk_appended_;
-
-  // True if an error occcured during read operation.
-  bool read_failed_;
 
   // True if the initialization was successful.
   bool initialized_successfully_;
 
-  // Callback to resume reading chunked data.
-  base::Closure pending_chunked_read_callback_;
+  bool is_eof_;
 
-  base::WeakPtrFactory<UploadDataStream> weak_ptr_factory_;
+  CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(UploadDataStream);
 };
diff --git a/net/base/upload_element_reader.h b/net/base/upload_element_reader.h
index d71f57c..a46b970 100644
--- a/net/base/upload_element_reader.h
+++ b/net/base/upload_element_reader.h
@@ -35,8 +35,8 @@
   // state.
   virtual int Init(const CompletionCallback& callback) = 0;
 
-  // Returns the byte-length of the element.  For files that do not exist, 0
-  // is returned.  This is done for consistency with Mozilla.
+  // Returns the byte-length of the element. For files that do not exist, 0
+  // is returned. This is done for consistency with Mozilla.
   virtual uint64 GetContentLength() const = 0;
 
   // Returns the number of bytes remaining to read.
diff --git a/net/base/upload_file_element_reader.h b/net/base/upload_file_element_reader.h
index 88e95bf..dc27585 100644
--- a/net/base/upload_file_element_reader.h
+++ b/net/base/upload_file_element_reader.h
@@ -42,16 +42,16 @@
   }
 
   // UploadElementReader overrides:
-  virtual const UploadFileElementReader* AsFileReader() const OVERRIDE;
-  virtual int Init(const CompletionCallback& callback) OVERRIDE;
-  virtual uint64 GetContentLength() const OVERRIDE;
-  virtual uint64 BytesRemaining() const OVERRIDE;
+  virtual const UploadFileElementReader* AsFileReader() const override;
+  virtual int Init(const CompletionCallback& callback) override;
+  virtual uint64 GetContentLength() const override;
+  virtual uint64 BytesRemaining() const override;
   virtual int Read(IOBuffer* buf,
                    int buf_length,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
 
  private:
-  FRIEND_TEST_ALL_PREFIXES(UploadDataStreamTest, FileSmallerThanLength);
+  FRIEND_TEST_ALL_PREFIXES(ElementsUploadDataStreamTest, FileSmallerThanLength);
   FRIEND_TEST_ALL_PREFIXES(HttpNetworkTransactionTest,
                            UploadFileSmallerThanLength);
 
diff --git a/net/cert/cert_verify_proc_android.h b/net/cert/cert_verify_proc_android.h
index ca8746b..7002718 100644
--- a/net/cert/cert_verify_proc_android.h
+++ b/net/cert/cert_verify_proc_android.h
@@ -15,7 +15,7 @@
  public:
   CertVerifyProcAndroid();
 
-  virtual bool SupportsAdditionalTrustAnchors() const OVERRIDE;
+  virtual bool SupportsAdditionalTrustAnchors() const override;
 
  protected:
   virtual ~CertVerifyProcAndroid();
@@ -26,7 +26,7 @@
                              int flags,
                              CRLSet* crl_set,
                              const CertificateList& additional_trust_anchors,
-                             CertVerifyResult* verify_result) OVERRIDE;
+                             CertVerifyResult* verify_result) override;
 };
 
 }  // namespace net
diff --git a/net/cert/cert_verify_proc_mac.h b/net/cert/cert_verify_proc_mac.h
index cb55767..f26768f 100644
--- a/net/cert/cert_verify_proc_mac.h
+++ b/net/cert/cert_verify_proc_mac.h
@@ -15,7 +15,7 @@
  public:
   CertVerifyProcMac();
 
-  virtual bool SupportsAdditionalTrustAnchors() const OVERRIDE;
+  virtual bool SupportsAdditionalTrustAnchors() const override;
 
  protected:
   virtual ~CertVerifyProcMac();
@@ -26,7 +26,7 @@
                              int flags,
                              CRLSet* crl_set,
                              const CertificateList& additional_trust_anchors,
-                             CertVerifyResult* verify_result) OVERRIDE;
+                             CertVerifyResult* verify_result) override;
 };
 
 }  // namespace net
diff --git a/net/cert/cert_verify_proc_nss.h b/net/cert/cert_verify_proc_nss.h
index d9971cf..e3eb11f 100644
--- a/net/cert/cert_verify_proc_nss.h
+++ b/net/cert/cert_verify_proc_nss.h
@@ -17,7 +17,7 @@
  public:
   CertVerifyProcNSS();
 
-  virtual bool SupportsAdditionalTrustAnchors() const OVERRIDE;
+  virtual bool SupportsAdditionalTrustAnchors() const override;
 
  protected:
   virtual ~CertVerifyProcNSS();
@@ -39,7 +39,7 @@
                              int flags,
                              CRLSet* crl_set,
                              const CertificateList& additional_trust_anchors,
-                             CertVerifyResult* verify_result) OVERRIDE;
+                             CertVerifyResult* verify_result) override;
 };
 
 }  // namespace net
diff --git a/net/cert/cert_verify_proc_openssl.h b/net/cert/cert_verify_proc_openssl.h
index d0d2574..ab1d0a3 100644
--- a/net/cert/cert_verify_proc_openssl.h
+++ b/net/cert/cert_verify_proc_openssl.h
@@ -14,7 +14,7 @@
  public:
   CertVerifyProcOpenSSL();
 
-  virtual bool SupportsAdditionalTrustAnchors() const OVERRIDE;
+  virtual bool SupportsAdditionalTrustAnchors() const override;
 
  protected:
   virtual ~CertVerifyProcOpenSSL();
@@ -25,7 +25,7 @@
                              int flags,
                              CRLSet* crl_set,
                              const CertificateList& additional_trust_anchors,
-                             CertVerifyResult* verify_result) OVERRIDE;
+                             CertVerifyResult* verify_result) override;
 };
 
 }  // namespace net
diff --git a/net/cert/cert_verify_proc_unittest.cc b/net/cert/cert_verify_proc_unittest.cc
index 6890052..a71aa9a 100644
--- a/net/cert/cert_verify_proc_unittest.cc
+++ b/net/cert/cert_verify_proc_unittest.cc
@@ -58,7 +58,7 @@
       : is_well_known_(is_well_known) {}
 
   // CertVerifyProc implementation:
-  virtual bool SupportsAdditionalTrustAnchors() const OVERRIDE { return false; }
+  virtual bool SupportsAdditionalTrustAnchors() const override { return false; }
 
  protected:
   virtual ~WellKnownCaCertVerifyProc() {}
@@ -69,7 +69,7 @@
                              int flags,
                              CRLSet* crl_set,
                              const CertificateList& additional_trust_anchors,
-                             CertVerifyResult* verify_result) OVERRIDE;
+                             CertVerifyResult* verify_result) override;
 
   const bool is_well_known_;
 
diff --git a/net/cert/cert_verify_proc_win.h b/net/cert/cert_verify_proc_win.h
index 147f47a..afcb838 100644
--- a/net/cert/cert_verify_proc_win.h
+++ b/net/cert/cert_verify_proc_win.h
@@ -15,7 +15,7 @@
  public:
   CertVerifyProcWin();
 
-  virtual bool SupportsAdditionalTrustAnchors() const OVERRIDE;
+  virtual bool SupportsAdditionalTrustAnchors() const override;
 
  protected:
   virtual ~CertVerifyProcWin();
@@ -26,7 +26,7 @@
                              int flags,
                              CRLSet* crl_set,
                              const CertificateList& additional_trust_anchors,
-                             CertVerifyResult* verify_result) OVERRIDE;
+                             CertVerifyResult* verify_result) override;
 };
 
 }  // namespace net
diff --git a/net/cert/ct_log_verifier_unittest.cc b/net/cert/ct_log_verifier_unittest.cc
index 23cbf51..e2918c9 100644
--- a/net/cert/ct_log_verifier_unittest.cc
+++ b/net/cert/ct_log_verifier_unittest.cc
@@ -18,7 +18,7 @@
  public:
   CTLogVerifierTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     log_ = CTLogVerifier::Create(ct::GetTestPublicKey(), "testlog").Pass();
 
     ASSERT_TRUE(log_);
diff --git a/net/cert/ct_objects_extractor_unittest.cc b/net/cert/ct_objects_extractor_unittest.cc
index 5feff3e..ac46755 100644
--- a/net/cert/ct_objects_extractor_unittest.cc
+++ b/net/cert/ct_objects_extractor_unittest.cc
@@ -20,7 +20,7 @@
 
 class CTObjectsExtractorTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     precert_chain_ =
         CreateCertificateListFromFile(GetTestCertsDirectory(),
                                       "ct-test-embedded-cert.pem",
diff --git a/net/cert/ct_serialization_unittest.cc b/net/cert/ct_serialization_unittest.cc
index 866f961..ccf2d20 100644
--- a/net/cert/ct_serialization_unittest.cc
+++ b/net/cert/ct_serialization_unittest.cc
@@ -20,7 +20,7 @@
 
 class CtSerializationTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     test_digitally_signed_ = ct::GetTestDigitallySigned();
   }
 
diff --git a/net/cert/ev_root_ca_metadata_unittest.cc b/net/cert/ev_root_ca_metadata_unittest.cc
index 1bb5475..90f4fa1 100644
--- a/net/cert/ev_root_ca_metadata_unittest.cc
+++ b/net/cert/ev_root_ca_metadata_unittest.cc
@@ -94,7 +94,7 @@
 
 class EVRootCAMetadataTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(ev_oid_data.Init());
   }
 
diff --git a/net/cert/mock_cert_verifier.h b/net/cert/mock_cert_verifier.h
index 5af7b7e..e76f78f 100644
--- a/net/cert/mock_cert_verifier.h
+++ b/net/cert/mock_cert_verifier.h
@@ -32,8 +32,8 @@
                      CertVerifyResult* verify_result,
                      const CompletionCallback& callback,
                      RequestHandle* out_req,
-                     const BoundNetLog& net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle req) OVERRIDE;
+                     const BoundNetLog& net_log) override;
+  virtual void CancelRequest(RequestHandle req) override;
 
   // Sets the default return value for Verify() for certificates/hosts that do
   // not have explicit results added via the AddResult*() methods.
diff --git a/net/cert/multi_log_ct_verifier.h b/net/cert/multi_log_ct_verifier.h
index 29fbdca..70adf52 100644
--- a/net/cert/multi_log_ct_verifier.h
+++ b/net/cert/multi_log_ct_verifier.h
@@ -41,7 +41,7 @@
                      const std::string& stapled_ocsp_response,
                      const std::string& sct_list_from_tls_extension,
                      ct::CTVerifyResult* result,
-                     const BoundNetLog& net_log) OVERRIDE;
+                     const BoundNetLog& net_log) override;
 
  private:
   // Mapping from a log's ID to the verifier for this log.
diff --git a/net/cert/multi_log_ct_verifier_unittest.cc b/net/cert/multi_log_ct_verifier_unittest.cc
index 8edf4eb..17a670c 100644
--- a/net/cert/multi_log_ct_verifier_unittest.cc
+++ b/net/cert/multi_log_ct_verifier_unittest.cc
@@ -37,7 +37,7 @@
 
 class MultiLogCTVerifierTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     scoped_ptr<CTLogVerifier> log(
         CTLogVerifier::Create(ct::GetTestPublicKey(), kLogDescription));
     ASSERT_TRUE(log);
diff --git a/net/cert/multi_threaded_cert_verifier.h b/net/cert/multi_threaded_cert_verifier.h
index cdd3235..2ca10f1 100644
--- a/net/cert/multi_threaded_cert_verifier.h
+++ b/net/cert/multi_threaded_cert_verifier.h
@@ -61,9 +61,9 @@
                      CertVerifyResult* verify_result,
                      const CompletionCallback& callback,
                      CertVerifier::RequestHandle* out_req,
-                     const BoundNetLog& net_log) OVERRIDE;
+                     const BoundNetLog& net_log) override;
 
-  virtual void CancelRequest(CertVerifier::RequestHandle req) OVERRIDE;
+  virtual void CancelRequest(CertVerifier::RequestHandle req) override;
 
  private:
   friend class CertVerifierWorker;  // Calls HandleResult.
@@ -137,7 +137,7 @@
                     const CertVerifyResult& verify_result);
 
   // CertDatabase::Observer methods:
-  virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE;
+  virtual void OnCACertChanged(const X509Certificate* cert) override;
 
   // For unit testing.
   void ClearCache() { cache_.Clear(); }
diff --git a/net/cert/multi_threaded_cert_verifier_unittest.cc b/net/cert/multi_threaded_cert_verifier_unittest.cc
index bf7de6d..651f78e 100644
--- a/net/cert/multi_threaded_cert_verifier_unittest.cc
+++ b/net/cert/multi_threaded_cert_verifier_unittest.cc
@@ -39,7 +39,7 @@
   virtual ~MockCertVerifyProc() {}
 
   // CertVerifyProc implementation
-  virtual bool SupportsAdditionalTrustAnchors() const OVERRIDE {
+  virtual bool SupportsAdditionalTrustAnchors() const override {
     return false;
   }
 
@@ -48,7 +48,7 @@
                              int flags,
                              CRLSet* crl_set,
                              const CertificateList& additional_trust_anchors,
-                             CertVerifyResult* verify_result) OVERRIDE {
+                             CertVerifyResult* verify_result) override {
     verify_result->Reset();
     verify_result->verified_cert = cert;
     verify_result->cert_status = CERT_STATUS_COMMON_NAME_INVALID;
diff --git a/net/cert/nss_cert_database.cc b/net/cert/nss_cert_database.cc
index 9707973..2c40e15 100644
--- a/net/cert/nss_cert_database.cc
+++ b/net/cert/nss_cert_database.cc
@@ -51,15 +51,15 @@
   virtual ~CertNotificationForwarder() {}
 
   // NSSCertDatabase::Observer implementation:
-  virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE {
+  virtual void OnCertAdded(const X509Certificate* cert) override {
     cert_db_->NotifyObserversOfCertAdded(cert);
   }
 
-  virtual void OnCertRemoved(const X509Certificate* cert) OVERRIDE {
+  virtual void OnCertRemoved(const X509Certificate* cert) override {
     cert_db_->NotifyObserversOfCertRemoved(cert);
   }
 
-  virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE {
+  virtual void OnCACertChanged(const X509Certificate* cert) override {
     cert_db_->NotifyObserversOfCACertChanged(cert);
   }
 
diff --git a/net/cert/nss_cert_database_chromeos.h b/net/cert/nss_cert_database_chromeos.h
index dfcefec..171ce28 100644
--- a/net/cert/nss_cert_database_chromeos.h
+++ b/net/cert/nss_cert_database_chromeos.h
@@ -25,12 +25,12 @@
   void SetSystemSlot(crypto::ScopedPK11Slot system_slot);
 
   // NSSCertDatabase implementation.
-  virtual void ListCertsSync(CertificateList* certs) OVERRIDE;
+  virtual void ListCertsSync(CertificateList* certs) override;
   virtual void ListCerts(const NSSCertDatabase::ListCertsCallback& callback)
-      OVERRIDE;
+      override;
   virtual void ListModules(CryptoModuleList* modules, bool need_rw) const
-      OVERRIDE;
-  virtual crypto::ScopedPK11Slot GetSystemSlot() const OVERRIDE;
+      override;
+  virtual crypto::ScopedPK11Slot GetSystemSlot() const override;
 
   // TODO(mattm): handle trust setting, deletion, etc correctly when certs exist
   // in multiple slots.
diff --git a/net/cert/nss_cert_database_chromeos_unittest.cc b/net/cert/nss_cert_database_chromeos_unittest.cc
index 5f790c9..caf5ea9 100644
--- a/net/cert/nss_cert_database_chromeos_unittest.cc
+++ b/net/cert/nss_cert_database_chromeos_unittest.cc
@@ -48,7 +48,7 @@
   NSSCertDatabaseChromeOSTest()
       : observer_added_(false), user_1_("user1"), user_2_("user2") {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // Initialize nss_util slots.
     ASSERT_TRUE(user_1_.constructed_successfully());
     ASSERT_TRUE(user_2_.constructed_successfully());
@@ -77,19 +77,19 @@
     observer_added_ = true;
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (observer_added_)
       CertDatabase::GetInstance()->RemoveObserver(this);
   }
 
   // CertDatabase::Observer:
-  virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE {
+  virtual void OnCertAdded(const X509Certificate* cert) override {
     added_.push_back(cert ? cert->os_cert_handle() : NULL);
   }
 
-  virtual void OnCertRemoved(const X509Certificate* cert) OVERRIDE {}
+  virtual void OnCertRemoved(const X509Certificate* cert) override {}
 
-  virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE {
+  virtual void OnCACertChanged(const X509Certificate* cert) override {
     added_ca_.push_back(cert ? cert->os_cert_handle() : NULL);
   }
 
diff --git a/net/cert/nss_profile_filter_chromeos_unittest.cc b/net/cert/nss_profile_filter_chromeos_unittest.cc
index b48a527..1ebf399 100644
--- a/net/cert/nss_profile_filter_chromeos_unittest.cc
+++ b/net/cert/nss_profile_filter_chromeos_unittest.cc
@@ -58,7 +58,7 @@
  public:
   NSSProfileFilterChromeOSTest() : user_1_("user1"), user_2_("user2") {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(system_slot_user_.is_open());
     ASSERT_TRUE(user_1_.constructed_successfully());
     ASSERT_TRUE(user_2_.constructed_successfully());
diff --git a/net/cert/signed_certificate_timestamp_unittest.cc b/net/cert/signed_certificate_timestamp_unittest.cc
index c758d65..dc60a27 100644
--- a/net/cert/signed_certificate_timestamp_unittest.cc
+++ b/net/cert/signed_certificate_timestamp_unittest.cc
@@ -20,7 +20,7 @@
 
 class SignedCertificateTimestampTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     GetX509CertSCT(&sample_sct_);
     sample_sct_->origin = SignedCertificateTimestamp::SCT_FROM_OCSP_RESPONSE;
     sample_sct_->log_description = kLogDescription;
diff --git a/net/cookies/cookie_monster.cc b/net/cookies/cookie_monster.cc
index 4244f76..10a6f6b 100644
--- a/net/cookies/cookie_monster.cc
+++ b/net/cookies/cookie_monster.cc
@@ -428,7 +428,7 @@
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~SetCookieWithDetailsTask() {}
@@ -468,7 +468,7 @@
   }
 
   // CookieMonsterTask
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~GetAllCookiesTask() {}
@@ -503,7 +503,7 @@
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~GetAllCookiesForURLWithOptionsTask() {}
@@ -544,7 +544,7 @@
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   // Runs the delete task and returns a result.
@@ -596,7 +596,7 @@
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteAllTask() {}
@@ -622,7 +622,7 @@
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteAllCreatedBetweenTask() {}
@@ -650,7 +650,7 @@
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteAllForHostTask() {}
@@ -682,7 +682,7 @@
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteAllCreatedBetweenForHostTask() {}
@@ -711,7 +711,7 @@
   }
 
   // DeleteTask:
-  virtual bool RunDeleteTask() OVERRIDE;
+  virtual bool RunDeleteTask() override;
 
  protected:
   virtual ~DeleteCanonicalCookieTask() {}
@@ -742,7 +742,7 @@
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~SetCookieWithOptionsTask() {}
@@ -779,7 +779,7 @@
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~GetCookiesWithOptionsTask() {}
@@ -814,7 +814,7 @@
   }
 
   // DeleteTask:
-  virtual void RunDeleteTask() OVERRIDE;
+  virtual void RunDeleteTask() override;
 
  protected:
   virtual ~DeleteCookieTask() {}
@@ -839,7 +839,7 @@
   }
 
   // DeleteTask:
-  virtual int RunDeleteTask() OVERRIDE;
+  virtual int RunDeleteTask() override;
 
  protected:
   virtual ~DeleteSessionCookiesTask() {}
@@ -865,7 +865,7 @@
   }
 
   // CookieMonsterTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~HasCookiesForETLDP1Task() {}
diff --git a/net/cookies/cookie_monster.h b/net/cookies/cookie_monster.h
index ea448c5..746f2a4 100644
--- a/net/cookies/cookie_monster.h
+++ b/net/cookies/cookie_monster.h
@@ -243,7 +243,7 @@
       const GURL& url,
       const std::string& cookie_line,
       const CookieOptions& options,
-      const SetCookiesCallback& callback) OVERRIDE;
+      const SetCookiesCallback& callback) override;
 
   // Gets all cookies that apply to |url| given |options|.
   // The returned cookies are ordered by longest path, then earliest
@@ -251,18 +251,18 @@
   virtual void GetCookiesWithOptionsAsync(
       const GURL& url,
       const CookieOptions& options,
-      const GetCookiesCallback& callback) OVERRIDE;
+      const GetCookiesCallback& callback) override;
 
   // Invokes GetAllCookiesForURLWithOptions with options set to include HTTP
   // only cookies.
   virtual void GetAllCookiesForURLAsync(
       const GURL& url,
-      const GetCookieListCallback& callback) OVERRIDE;
+      const GetCookieListCallback& callback) override;
 
   // Deletes all cookies with that might apply to |url| that has |cookie_name|.
   virtual void DeleteCookieAsync(
       const GURL& url, const std::string& cookie_name,
-      const base::Closure& callback) OVERRIDE;
+      const base::Closure& callback) override;
 
   // Deletes all of the cookies that have a creation_date greater than or equal
   // to |delete_begin| and less than |delete_end|.
@@ -270,7 +270,7 @@
   virtual void DeleteAllCreatedBetweenAsync(
       const base::Time& delete_begin,
       const base::Time& delete_end,
-      const DeleteCallback& callback) OVERRIDE;
+      const DeleteCallback& callback) override;
 
   // Deletes all of the cookies that match the host of the given URL
   // regardless of path and that have a creation_date greater than or
@@ -282,11 +282,11 @@
       const base::Time delete_begin,
       const base::Time delete_end,
       const GURL& url,
-      const DeleteCallback& callback) OVERRIDE;
+      const DeleteCallback& callback) override;
 
-  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) OVERRIDE;
+  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) override;
 
-  virtual CookieMonster* GetCookieMonster() OVERRIDE;
+  virtual CookieMonster* GetCookieMonster() override;
 
   // Enables writing session cookies into the cookie database. If this this
   // method is called, it must be called before first use of the instance
diff --git a/net/cookies/cookie_monster_store_test.h b/net/cookies/cookie_monster_store_test.h
index efbcbe5..c3a2827 100644
--- a/net/cookies/cookie_monster_store_test.h
+++ b/net/cookies/cookie_monster_store_test.h
@@ -82,22 +82,22 @@
     return commands_;
   }
 
-  virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE;
+  virtual void Load(const LoadedCallback& loaded_callback) override;
 
   virtual void LoadCookiesForKey(const std::string& key,
-    const LoadedCallback& loaded_callback) OVERRIDE;
+    const LoadedCallback& loaded_callback) override;
 
-  virtual void AddCookie(const CanonicalCookie& cookie) OVERRIDE;
+  virtual void AddCookie(const CanonicalCookie& cookie) override;
 
   virtual void UpdateCookieAccessTime(
-      const CanonicalCookie& cookie) OVERRIDE;
+      const CanonicalCookie& cookie) override;
 
   virtual void DeleteCookie(
-      const CanonicalCookie& cookie) OVERRIDE;
+      const CanonicalCookie& cookie) override;
 
-  virtual void Flush(const base::Closure& callback) OVERRIDE;
+  virtual void Flush(const base::Closure& callback) override;
 
-  virtual void SetForceKeepSessionState() OVERRIDE;
+  virtual void SetForceKeepSessionState() override;
 
  protected:
   virtual ~MockPersistentCookieStore();
@@ -130,9 +130,9 @@
   virtual void OnCookieChanged(
       const CanonicalCookie& cookie,
       bool removed,
-      CookieMonsterDelegate::ChangeCause cause) OVERRIDE;
+      CookieMonsterDelegate::ChangeCause cause) override;
 
-  virtual void OnLoaded() OVERRIDE;
+  virtual void OnLoaded() override;
 
  private:
   virtual ~MockCookieMonsterDelegate();
@@ -161,20 +161,20 @@
  public:
   MockSimplePersistentCookieStore();
 
-  virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE;
+  virtual void Load(const LoadedCallback& loaded_callback) override;
 
   virtual void LoadCookiesForKey(const std::string& key,
-      const LoadedCallback& loaded_callback) OVERRIDE;
+      const LoadedCallback& loaded_callback) override;
 
-  virtual void AddCookie(const CanonicalCookie& cookie) OVERRIDE;
+  virtual void AddCookie(const CanonicalCookie& cookie) override;
 
-  virtual void UpdateCookieAccessTime(const CanonicalCookie& cookie) OVERRIDE;
+  virtual void UpdateCookieAccessTime(const CanonicalCookie& cookie) override;
 
-  virtual void DeleteCookie(const CanonicalCookie& cookie) OVERRIDE;
+  virtual void DeleteCookie(const CanonicalCookie& cookie) override;
 
-  virtual void Flush(const base::Closure& callback) OVERRIDE;
+  virtual void Flush(const base::Closure& callback) override;
 
-  virtual void SetForceKeepSessionState() OVERRIDE;
+  virtual void SetForceKeepSessionState() override;
 
  protected:
   virtual ~MockSimplePersistentCookieStore();
diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc
index 0610612..a328487 100644
--- a/net/cookies/cookie_monster_unittest.cc
+++ b/net/cookies/cookie_monster_unittest.cc
@@ -2165,7 +2165,7 @@
  public:
   FlushablePersistentStore() : flush_count_(0) {}
 
-  virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE {
+  virtual void Load(const LoadedCallback& loaded_callback) override {
     std::vector<CanonicalCookie*> out_cookies;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
@@ -2175,16 +2175,16 @@
 
   virtual void LoadCookiesForKey(
       const std::string& key,
-      const LoadedCallback& loaded_callback) OVERRIDE {
+      const LoadedCallback& loaded_callback) override {
     Load(loaded_callback);
   }
 
-  virtual void AddCookie(const CanonicalCookie&) OVERRIDE {}
-  virtual void UpdateCookieAccessTime(const CanonicalCookie&) OVERRIDE {}
-  virtual void DeleteCookie(const CanonicalCookie&) OVERRIDE {}
-  virtual void SetForceKeepSessionState() OVERRIDE {}
+  virtual void AddCookie(const CanonicalCookie&) override {}
+  virtual void UpdateCookieAccessTime(const CanonicalCookie&) override {}
+  virtual void DeleteCookie(const CanonicalCookie&) override {}
+  virtual void SetForceKeepSessionState() override {}
 
-  virtual void Flush(const base::Closure& callback) OVERRIDE {
+  virtual void Flush(const base::Closure& callback) override {
     ++flush_count_;
     if (!callback.is_null())
       callback.Run();
diff --git a/net/cookies/cookie_store_test_helpers.h b/net/cookies/cookie_store_test_helpers.h
index 84b83bc..e4e7156 100644
--- a/net/cookies/cookie_store_test_helpers.h
+++ b/net/cookies/cookie_store_test_helpers.h
@@ -27,16 +27,16 @@
       const GURL& url,
       const std::string& cookie_line,
       const CookieOptions& options,
-      const CookieMonster::SetCookiesCallback& callback) OVERRIDE;
+      const CookieMonster::SetCookiesCallback& callback) override;
 
   virtual void GetCookiesWithOptionsAsync(
       const GURL& url,
       const CookieOptions& options,
-      const CookieMonster::GetCookiesCallback& callback) OVERRIDE;
+      const CookieMonster::GetCookiesCallback& callback) override;
 
   virtual void GetAllCookiesForURLAsync(
       const GURL& url,
-      const GetCookieListCallback& callback) OVERRIDE;
+      const GetCookieListCallback& callback) override;
 
   virtual bool SetCookieWithOptions(const GURL& url,
                                     const std::string& cookie_line,
@@ -50,22 +50,22 @@
 
   virtual void DeleteCookieAsync(const GURL& url,
                                  const std::string& cookie_name,
-                                 const base::Closure& callback) OVERRIDE;
+                                 const base::Closure& callback) override;
 
   virtual void DeleteAllCreatedBetweenAsync(
       const base::Time& delete_begin,
       const base::Time& delete_end,
-      const DeleteCallback& callback) OVERRIDE;
+      const DeleteCallback& callback) override;
 
   virtual void DeleteAllCreatedBetweenForHostAsync(
       const base::Time delete_begin,
       const base::Time delete_end,
       const GURL& url,
-      const DeleteCallback& callback) OVERRIDE;
+      const DeleteCallback& callback) override;
 
-  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) OVERRIDE;
+  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) override;
 
-  virtual CookieMonster* GetCookieMonster() OVERRIDE;
+  virtual CookieMonster* GetCookieMonster() override;
 
  private:
 
diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc
index 572691c..b3b80b4 100644
--- a/net/disk_cache/backend_unittest.cc
+++ b/net/disk_cache/backend_unittest.cc
@@ -1843,7 +1843,7 @@
   virtual ~BadEntropyProvider() {}
 
   virtual double GetEntropyForTrial(const std::string& trial_name,
-                                    uint32 randomization_seed) const OVERRIDE {
+                                    uint32 randomization_seed) const override {
     return 0.5;
   }
 };
diff --git a/net/disk_cache/blockfile/backend_impl.cc b/net/disk_cache/blockfile/backend_impl.cc
index 4082743..bcac374 100644
--- a/net/disk_cache/blockfile/backend_impl.cc
+++ b/net/disk_cache/blockfile/backend_impl.cc
@@ -1260,7 +1260,7 @@
   }
 
   virtual int OpenNextEntry(Entry** next_entry,
-                            const net::CompletionCallback& callback) OVERRIDE {
+                            const net::CompletionCallback& callback) override {
     if (!background_queue_)
       return net::ERR_FAILED;
     background_queue_->OpenNextEntry(iterator_.get(), next_entry, callback);
diff --git a/net/disk_cache/blockfile/backend_impl.h b/net/disk_cache/blockfile/backend_impl.h
index 1abc66d..e81b928 100644
--- a/net/disk_cache/blockfile/backend_impl.h
+++ b/net/disk_cache/blockfile/backend_impl.h
@@ -259,20 +259,20 @@
   void FlushIndex();
 
   // Backend implementation.
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
-                                 const CompletionCallback& callback) OVERRIDE;
+                                 const CompletionCallback& callback) override;
   virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
   // NOTE: The blockfile Backend::Iterator::OpenNextEntry method does not modify
   // the last_used field of the entry, and therefore it does not impact the
   // eviction ranking of the entry. However, an enumeration will go through all
@@ -281,9 +281,9 @@
   // the iterator (for example, deleting the entry) will invalidate the
   // iterator. Performing operations on an entry that modify the entry may
   // result in loops in the iteration, skipped entries or similar.
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
-  virtual void GetStats(StatsItems* stats) OVERRIDE;
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
+  virtual void GetStats(StatsItems* stats) override;
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
  private:
   typedef base::hash_map<CacheAddr, EntryImpl*> EntriesMap;
diff --git a/net/disk_cache/blockfile/backend_impl_v3.cc b/net/disk_cache/blockfile/backend_impl_v3.cc
index b44b195..09794d3 100644
--- a/net/disk_cache/blockfile/backend_impl_v3.cc
+++ b/net/disk_cache/blockfile/backend_impl_v3.cc
@@ -667,7 +667,7 @@
   }
 
   virtual int OpenNextEntry(Entry** next_entry,
-                            const net::CompletionCallback& callback) OVERRIDE {
+                            const net::CompletionCallback& callback) override {
     if (!background_queue_)
       return net::ERR_FAILED;
     background_queue_->OpenNextEntry(&data_, next_entry, callback);
@@ -1511,7 +1511,7 @@
 class BackendImplV3::NotImplementedIterator : public Backend::Iterator {
  public:
   virtual int OpenNextEntry(disk_cache::Entry** next_entry,
-                            const net::CompletionCallback& callback) OVERRIDE {
+                            const net::CompletionCallback& callback) override {
     return net::ERR_NOT_IMPLEMENTED;
   }
 };
diff --git a/net/disk_cache/blockfile/backend_impl_v3.h b/net/disk_cache/blockfile/backend_impl_v3.h
index ca64997..6f4f882 100644
--- a/net/disk_cache/blockfile/backend_impl_v3.h
+++ b/net/disk_cache/blockfile/backend_impl_v3.h
@@ -172,23 +172,23 @@
   int SelfCheck();
 
   // Backend implementation.
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
-                                 const CompletionCallback& callback) OVERRIDE;
+                                 const CompletionCallback& callback) override;
   virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
-  virtual void GetStats(StatsItems* stats) OVERRIDE;
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
+  virtual void GetStats(StatsItems* stats) override;
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
  private:
   friend class EvictionV3;
diff --git a/net/disk_cache/blockfile/entry_impl.cc b/net/disk_cache/blockfile/entry_impl.cc
index 3c3b218..2b98470 100644
--- a/net/disk_cache/blockfile/entry_impl.cc
+++ b/net/disk_cache/blockfile/entry_impl.cc
@@ -46,7 +46,7 @@
   }
   virtual ~SyncCallback() {}
 
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
+  virtual void OnFileIOComplete(int bytes_copied) override;
   void Discard();
 
  private:
diff --git a/net/disk_cache/blockfile/entry_impl.h b/net/disk_cache/blockfile/entry_impl.h
index c0b332b..fea815d 100644
--- a/net/disk_cache/blockfile/entry_impl.h
+++ b/net/disk_cache/blockfile/entry_impl.h
@@ -147,26 +147,26 @@
   static int NumBlocksForEntry(int key_size);
 
   // Entry interface.
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                         const CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                             const CompletionCallback& callback) OVERRIDE;
+                             const CompletionCallback& callback) override;
   virtual int WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                const CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE;
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
+                                const CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override;
+  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   enum {
diff --git a/net/disk_cache/blockfile/entry_impl_v3.h b/net/disk_cache/blockfile/entry_impl_v3.h
index 6be0c71..4215000 100644
--- a/net/disk_cache/blockfile/entry_impl_v3.h
+++ b/net/disk_cache/blockfile/entry_impl_v3.h
@@ -77,26 +77,26 @@
   const net::BoundNetLog& net_log() const;
 
   // Entry interface.
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                         const CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                             const CompletionCallback& callback) OVERRIDE;
+                             const CompletionCallback& callback) override;
   virtual int WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                const CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE;
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
+                                const CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override;
+  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   enum {
diff --git a/net/disk_cache/blockfile/file_ios.cc b/net/disk_cache/blockfile/file_ios.cc
index 4659e75..ef0e2fa 100644
--- a/net/disk_cache/blockfile/file_ios.cc
+++ b/net/disk_cache/blockfile/file_ios.cc
@@ -80,7 +80,7 @@
   // queued (because we are inside WaitForPendingIO), and false if said task is
   // the one performing the call.
   virtual void OnOperationComplete(disk_cache::BackgroundIO* operation,
-                                   bool cancel) OVERRIDE;
+                                   bool cancel) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FileInFlightIO);
diff --git a/net/disk_cache/blockfile/in_flight_backend_io.cc b/net/disk_cache/blockfile/in_flight_backend_io.cc
index 28d7114..9bb011e 100644
--- a/net/disk_cache/blockfile/in_flight_backend_io.cc
+++ b/net/disk_cache/blockfile/in_flight_backend_io.cc
@@ -8,6 +8,7 @@
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/single_thread_task_runner.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
@@ -64,8 +65,14 @@
 
   if (result() == net::OK) {
     static_cast<EntryImpl*>(*entry_ptr_)->OnEntryCreated(backend_);
-    if (cancel)
+    if (cancel) {
+      // TODO(vadimt): Remove ScopedProfile below once crbug.com/422516 is
+      // fixed.
+      tracked_objects::ScopedProfile tracking_profile(
+          FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 BackendIO::OnDone"));
+
       (*entry_ptr_)->Close();
+    }
   }
 }
 
@@ -496,8 +503,14 @@
   BackendIO* op = static_cast<BackendIO*>(operation);
   op->OnDone(cancel);
 
-  if (!op->callback().is_null() && (!cancel || op->IsEntryOperation()))
+  if (!op->callback().is_null() && (!cancel || op->IsEntryOperation())) {
+    // TODO(vadimt): Remove ScopedProfile below once crbug.com/422516 is fixed.
+    tracked_objects::ScopedProfile tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422516 InFlightBackendIO::OnOperationComplete"));
+
     op->callback().Run(op->result());
+  }
 }
 
 void InFlightBackendIO::PostOperation(BackendIO* operation) {
diff --git a/net/disk_cache/blockfile/in_flight_backend_io.h b/net/disk_cache/blockfile/in_flight_backend_io.h
index 5d8e435..4b10405 100644
--- a/net/disk_cache/blockfile/in_flight_backend_io.h
+++ b/net/disk_cache/blockfile/in_flight_backend_io.h
@@ -205,7 +205,7 @@
 
  protected:
   virtual void OnOperationComplete(BackgroundIO* operation,
-                                   bool cancel) OVERRIDE;
+                                   bool cancel) override;
 
  private:
   void PostOperation(BackendIO* operation);
diff --git a/net/disk_cache/blockfile/in_flight_io.cc b/net/disk_cache/blockfile/in_flight_io.cc
index 9ada7c5..176cf87 100644
--- a/net/disk_cache/blockfile/in_flight_io.cc
+++ b/net/disk_cache/blockfile/in_flight_io.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ -87,6 +88,10 @@
 // Runs on the primary thread.
 void InFlightIO::InvokeCallback(BackgroundIO* operation, bool cancel_task) {
   {
+    // TODO(vadimt): Remove ScopedProfile below once crbug.com/422516 is fixed.
+    tracked_objects::ScopedProfile tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 InFlightIO::InvokeCallback"));
+
     // http://crbug.com/74623
     base::ThreadRestrictions::ScopedAllowWait allow_wait;
     operation->io_completed()->Wait();
diff --git a/net/disk_cache/blockfile/index_table_v3_unittest.cc b/net/disk_cache/blockfile/index_table_v3_unittest.cc
index b7a93a2..7f68ee3 100644
--- a/net/disk_cache/blockfile/index_table_v3_unittest.cc
+++ b/net/disk_cache/blockfile/index_table_v3_unittest.cc
@@ -35,12 +35,12 @@
   bool grow_called() const { return grow_called_; }
   int buffer_len() const { return buffer_len_; }
 
-  virtual void GrowIndex() OVERRIDE { grow_called_ = true; }
-  virtual void SaveIndex(net::IOBuffer* buffer, int buffer_len) OVERRIDE {
+  virtual void GrowIndex() override { grow_called_ = true; }
+  virtual void SaveIndex(net::IOBuffer* buffer, int buffer_len) override {
     buffer_len_ = buffer_len;
   }
-  virtual void DeleteCell(EntryCell cell) OVERRIDE {}
-  virtual void FixCell(EntryCell cell) OVERRIDE {}
+  virtual void DeleteCell(EntryCell cell) override {}
+  virtual void FixCell(EntryCell cell) override {}
 
  private:
   bool grow_called_;
diff --git a/net/disk_cache/blockfile/mapped_file_unittest.cc b/net/disk_cache/blockfile/mapped_file_unittest.cc
index 8b3a1d0..8093e9a 100644
--- a/net/disk_cache/blockfile/mapped_file_unittest.cc
+++ b/net/disk_cache/blockfile/mapped_file_unittest.cc
@@ -23,7 +23,7 @@
   }
   virtual ~FileCallbackTest() {}
 
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
+  virtual void OnFileIOComplete(int bytes_copied) override;
 
  private:
   int id_;
@@ -48,9 +48,9 @@
   virtual ~TestFileBlock() {}
 
   // FileBlock interface.
-  virtual void* buffer() const OVERRIDE { return const_cast<char*>(buffer_); }
-  virtual size_t size() const OVERRIDE { return sizeof(buffer_); }
-  virtual int offset() const OVERRIDE { return 1024; }
+  virtual void* buffer() const override { return const_cast<char*>(buffer_); }
+  virtual size_t size() const override { return sizeof(buffer_); }
+  virtual int offset() const override { return 1024; }
 
  private:
   char buffer_[20];
diff --git a/net/disk_cache/blockfile/sparse_control.cc b/net/disk_cache/blockfile/sparse_control.cc
index e251d84..ddb57b6 100644
--- a/net/disk_cache/blockfile/sparse_control.cc
+++ b/net/disk_cache/blockfile/sparse_control.cc
@@ -56,7 +56,7 @@
   ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name)
       : backend_(backend->GetWeakPtr()), name_(name), signature_(0) {}
 
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
+  virtual void OnFileIOComplete(int bytes_copied) override;
 
   // Two ways of deleting the children: if we have the children map, use Start()
   // directly, otherwise pass the data address to ReadData().
diff --git a/net/disk_cache/blockfile/sparse_control_v3.cc b/net/disk_cache/blockfile/sparse_control_v3.cc
index 66a60a2..cba0ed5 100644
--- a/net/disk_cache/blockfile/sparse_control_v3.cc
+++ b/net/disk_cache/blockfile/sparse_control_v3.cc
@@ -56,7 +56,7 @@
   ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name)
       : backend_(backend->GetWeakPtr()), name_(name), signature_(0) {}
 
-  virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
+  virtual void OnFileIOComplete(int bytes_copied) override;
 
   // Two ways of deleting the children: if we have the children map, use Start()
   // directly, otherwise pass the data address to ReadData().
diff --git a/net/disk_cache/cache_creator.cc b/net/disk_cache/cache_creator.cc
index 8c4400c..becb31c 100644
--- a/net/disk_cache/cache_creator.cc
+++ b/net/disk_cache/cache_creator.cc
@@ -4,6 +4,7 @@
 
 #include "base/files/file_path.h"
 #include "base/metrics/field_trial.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/cache_type.h"
@@ -139,6 +140,10 @@
 // If the initialization of the cache fails, and |force| is true, we will
 // discard the whole cache and create a new one.
 void CacheCreator::OnIOComplete(int result) {
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/422516 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 CacheCreator::OnIOComplete"));
+
   if (result == net::OK || !force_ || retry_)
     return DoCallback(result);
 
diff --git a/net/disk_cache/cache_util.cc b/net/disk_cache/cache_util.cc
index ea39df0..1671138 100644
--- a/net/disk_cache/cache_util.cc
+++ b/net/disk_cache/cache_util.cc
@@ -145,15 +145,12 @@
   if (available < 0)
     return kDefaultCacheSize;
 
-  int64 max_size = PreferredCacheSizeInternal(available);
-
   // Limit cache size to somewhat less than kint32max to avoid potential
   // integer overflows in cache backend implementations.
-  DCHECK(kDefaultCacheSize * 4 < kint32max);
-  if (max_size > kDefaultCacheSize * 4)
-    max_size = kDefaultCacheSize * 4;
-
-  return implicit_cast<int32>(max_size);
+  DCHECK_LT(kDefaultCacheSize * 4, kint32max);
+  return static_cast<int32>(std::min(
+      PreferredCacheSizeInternal(available),
+      static_cast<int64>(kDefaultCacheSize * 4)));
 }
 
 }  // namespace disk_cache
diff --git a/net/disk_cache/disk_cache_test_base.h b/net/disk_cache/disk_cache_test_base.h
index 225d37f..ce36f92 100644
--- a/net/disk_cache/disk_cache_test_base.h
+++ b/net/disk_cache/disk_cache_test_base.h
@@ -46,7 +46,7 @@
   // Deletes the contents of |cache_path_|.
   bool CleanupCacheDir();
 
-  virtual void TearDown() OVERRIDE;
+  virtual void TearDown() override;
 
   base::FilePath cache_path_;
 
@@ -154,7 +154,7 @@
   void AddDelay();
 
   // DiskCacheTest:
-  virtual void TearDown() OVERRIDE;
+  virtual void TearDown() override;
 
   // cache_ will always have a valid object, regardless of how the cache was
   // initialized. The implementation pointers can be NULL.
diff --git a/net/disk_cache/entry_unittest.cc b/net/disk_cache/entry_unittest.cc
index afe93ac..a3a7747 100644
--- a/net/disk_cache/entry_unittest.cc
+++ b/net/disk_cache/entry_unittest.cc
@@ -2063,7 +2063,7 @@
   }
 
  private:
-  virtual void SetResult(int result) OVERRIDE {
+  virtual void SetResult(int result) override {
     cache_.reset();
     TestCompletionCallback::SetResult(result);
   }
diff --git a/net/disk_cache/memory/mem_backend_impl.cc b/net/disk_cache/memory/mem_backend_impl.cc
index 848ef98..3a90075 100644
--- a/net/disk_cache/memory/mem_backend_impl.cc
+++ b/net/disk_cache/memory/mem_backend_impl.cc
@@ -188,7 +188,7 @@
   }
 
   virtual int OpenNextEntry(Entry** next_entry,
-                            const CompletionCallback& callback) OVERRIDE {
+                            const CompletionCallback& callback) override {
     if (!backend_)
       return net::ERR_FAILED;
 
diff --git a/net/disk_cache/memory/mem_backend_impl.h b/net/disk_cache/memory/mem_backend_impl.h
index 10946c5..46505ea 100644
--- a/net/disk_cache/memory/mem_backend_impl.h
+++ b/net/disk_cache/memory/mem_backend_impl.h
@@ -63,24 +63,24 @@
   void RemoveFromRankingList(MemEntryImpl* entry);
 
   // Backend interface.
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
-                                 const CompletionCallback& callback) OVERRIDE;
+                                 const CompletionCallback& callback) override;
   virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
   virtual void GetStats(
-      std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE {}
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+      std::vector<std::pair<std::string, std::string> >* stats) override {}
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
  private:
   class MemIterator;
diff --git a/net/disk_cache/memory/mem_entry_impl.h b/net/disk_cache/memory/mem_entry_impl.h
index aec8d22..d31e14a 100644
--- a/net/disk_cache/memory/mem_entry_impl.h
+++ b/net/disk_cache/memory/mem_entry_impl.h
@@ -87,26 +87,26 @@
   }
 
   // Entry interface.
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                         const CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                             const CompletionCallback& callback) OVERRIDE;
+                             const CompletionCallback& callback) override;
   virtual int WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int GetAvailableRange(int64 offset, int len, int64* start,
-                                const CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE {}
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
+                                const CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override {}
+  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   typedef base::hash_map<int, MemEntryImpl*> EntryMap;
diff --git a/net/disk_cache/simple/simple_backend_impl.cc b/net/disk_cache/simple/simple_backend_impl.cc
index b0cbd52..32b074a 100644
--- a/net/disk_cache/simple/simple_backend_impl.cc
+++ b/net/disk_cache/simple/simple_backend_impl.cc
@@ -467,7 +467,7 @@
   return DoomEntriesBetween(initial_time, Time(), callback);
 }
 
-class SimpleBackendImpl::SimpleIterator FINAL : public Iterator {
+class SimpleBackendImpl::SimpleIterator final : public Iterator {
  public:
   explicit SimpleIterator(base::WeakPtr<SimpleBackendImpl> backend)
       : backend_(backend),
@@ -476,7 +476,7 @@
 
   // From Backend::Iterator:
   virtual int OpenNextEntry(Entry** next_entry,
-                            const CompletionCallback& callback) OVERRIDE {
+                            const CompletionCallback& callback) override {
     CompletionCallback open_next_entry_impl =
         base::Bind(&SimpleIterator::OpenNextEntryImpl,
                    weak_factory_.GetWeakPtr(), next_entry, callback);
diff --git a/net/disk_cache/simple/simple_backend_impl.h b/net/disk_cache/simple/simple_backend_impl.h
index 48c422f..e5a50da 100644
--- a/net/disk_cache/simple/simple_backend_impl.h
+++ b/net/disk_cache/simple/simple_backend_impl.h
@@ -85,27 +85,27 @@
 
   // SimpleIndexDelegate:
   virtual void DoomEntries(std::vector<uint64>* entry_hashes,
-                           const CompletionCallback& callback) OVERRIDE;
+                           const CompletionCallback& callback) override;
 
   // Backend:
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, Entry** entry,
-                        const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, Entry** entry,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const CompletionCallback& callback) OVERRIDE;
+                        const CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(base::Time initial_time,
                                  base::Time end_time,
-                                 const CompletionCallback& callback) OVERRIDE;
+                                 const CompletionCallback& callback) override;
   virtual int DoomEntriesSince(base::Time initial_time,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
   virtual void GetStats(
-      std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE;
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+      std::vector<std::pair<std::string, std::string> >* stats) override;
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
  private:
   class SimpleIterator;
diff --git a/net/disk_cache/simple/simple_entry_impl.h b/net/disk_cache/simple/simple_entry_impl.h
index 2dfb757..7c11b96 100644
--- a/net/disk_cache/simple/simple_entry_impl.h
+++ b/net/disk_cache/simple/simple_entry_impl.h
@@ -80,38 +80,38 @@
   void SetKey(const std::string& key);
 
   // From Entry:
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int stream_index,
                        int offset,
                        net::IOBuffer* buf,
                        int buf_len,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int WriteData(int stream_index,
                         int offset,
                         net::IOBuffer* buf,
                         int buf_len,
                         const CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset,
                              net::IOBuffer* buf,
                              int buf_len,
-                             const CompletionCallback& callback) OVERRIDE;
+                             const CompletionCallback& callback) override;
   virtual int WriteSparseData(int64 offset,
                               net::IOBuffer* buf,
                               int buf_len,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int GetAvailableRange(int64 offset,
                                 int len,
                                 int64* start,
-                                const CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE;
-  virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
+                                const CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override;
+  virtual int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   class ScopedOperationRunner;
diff --git a/net/disk_cache/simple/simple_index.cc b/net/disk_cache/simple/simple_index.cc
index 02afe2d..ca4d58e 100644
--- a/net/disk_cache/simple/simple_index.cc
+++ b/net/disk_cache/simple/simple_index.cc
@@ -16,6 +16,7 @@
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/pickle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
@@ -103,15 +104,8 @@
     return;
   }
 
-  const base::TimeDelta since_unix_epoch =
-      last_used_time - base::Time::UnixEpoch();
-  const int64 seconds_since_unix_epoch = since_unix_epoch.InSeconds();
-  DCHECK_LE(implicit_cast<int64>(std::numeric_limits<uint32>::min()),
-            seconds_since_unix_epoch);
-  DCHECK_GE(implicit_cast<int64>(std::numeric_limits<uint32>::max()),
-            seconds_since_unix_epoch);
-
-  last_used_time_seconds_since_epoch_ = seconds_since_unix_epoch;
+  last_used_time_seconds_since_epoch_ = base::checked_cast<uint32>(
+      (last_used_time - base::Time::UnixEpoch()).InSeconds());
   // Avoid accidental nullity.
   if (last_used_time_seconds_since_epoch_ == 0)
     last_used_time_seconds_since_epoch_ = 1;
diff --git a/net/disk_cache/simple/simple_index.h b/net/disk_cache/simple/simple_index.h
index 7b5f543..2b7e1cd 100644
--- a/net/disk_cache/simple/simple_index.h
+++ b/net/disk_cache/simple/simple_index.h
@@ -62,11 +62,11 @@
  private:
   friend class SimpleIndexFileTest;
 
-  // When adding new members here, you should update the Serialize() and
-  // Deserialize() methods.
-
+  // There are tens of thousands of instances of EntryMetadata in memory, so the
+  // size of each entry matters.  Even when the values used to set these members
+  // are originally calculated as >32-bit types, the actual necessary size for
+  // each shouldn't exceed 32 bits, so we use 32-bit types here.
   uint32 last_used_time_seconds_since_epoch_;
-
   int32 entry_size_;  // Storage size in bytes.
 };
 COMPILE_ASSERT(sizeof(EntryMetadata) == 8, metadata_size);
diff --git a/net/disk_cache/simple/simple_index_unittest.cc b/net/disk_cache/simple/simple_index_unittest.cc
index 0afbaa2..0bb10d3 100644
--- a/net/disk_cache/simple/simple_index_unittest.cc
+++ b/net/disk_cache/simple/simple_index_unittest.cc
@@ -60,7 +60,7 @@
   virtual void LoadIndexEntries(
       base::Time cache_last_modified,
       const base::Closure& callback,
-      SimpleIndexLoadResult* out_load_result) OVERRIDE {
+      SimpleIndexLoadResult* out_load_result) override {
     load_callback_ = callback;
     load_result_ = out_load_result;
     ++load_index_entries_calls_;
@@ -69,7 +69,7 @@
   virtual void WriteToDisk(const SimpleIndex::EntrySet& entry_set,
                            uint64 cache_size,
                            const base::TimeTicks& start,
-                           bool app_on_background) OVERRIDE {
+                           bool app_on_background) override {
     disk_writes_++;
     disk_write_entry_set_ = entry_set;
   }
@@ -102,7 +102,7 @@
         base::StringPrintf("key%d", static_cast<int>(hash_index)));
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     scoped_ptr<MockSimpleIndexFile> index_file(new MockSimpleIndexFile());
     index_file_ = index_file->AsWeakPtr();
     index_.reset(new SimpleIndex(NULL, this, net::DISK_CACHE,
@@ -121,7 +121,7 @@
 
   // From SimpleIndexDelegate:
   virtual void DoomEntries(std::vector<uint64>* entry_hashes,
-                           const net::CompletionCallback& callback) OVERRIDE {
+                           const net::CompletionCallback& callback) override {
     std::for_each(entry_hashes->begin(), entry_hashes->end(),
                   std::bind1st(std::mem_fun(&SimpleIndex::Remove),
                                index_.get()));
diff --git a/net/disk_cache/simple/simple_net_log_parameters.cc b/net/disk_cache/simple/simple_net_log_parameters.cc
index 9acd663..4756c83 100644
--- a/net/disk_cache/simple/simple_net_log_parameters.cc
+++ b/net/disk_cache/simple/simple_net_log_parameters.cc
@@ -17,7 +17,7 @@
 
 base::Value* NetLogSimpleEntryConstructionCallback(
     const disk_cache::SimpleEntryImpl* entry,
-    net::NetLog::LogLevel log_level ALLOW_UNUSED) {
+    net::NetLog::LogLevel log_level) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("entry_hash",
                   base::StringPrintf("%#016" PRIx64, entry->entry_hash()));
diff --git a/net/disk_cache/simple/simple_synchronous_entry.cc b/net/disk_cache/simple/simple_synchronous_entry.cc
index 1e7b9aa..c50c9a3 100644
--- a/net/disk_cache/simple/simple_synchronous_entry.cc
+++ b/net/disk_cache/simple/simple_synchronous_entry.cc
@@ -14,6 +14,7 @@
 #include "base/files/file_util.h"
 #include "base/hash.h"
 #include "base/location.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/sha1.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
@@ -73,7 +74,7 @@
 void RecordSyncOpenResult(net::CacheType cache_type,
                           OpenEntryResult result,
                           bool had_index) {
-  DCHECK_GT(OPEN_ENTRY_MAX, result);
+  DCHECK_LT(result, OPEN_ENTRY_MAX);
   SIMPLE_CACHE_UMA(ENUMERATION,
                    "SyncOpenResult", cache_type, result, OPEN_ENTRY_MAX);
   if (had_index) {
@@ -104,8 +105,8 @@
 }
 
 bool CanOmitEmptyFile(int file_index) {
-  DCHECK_LE(0, file_index);
-  DCHECK_GT(disk_cache::kSimpleEntryFileCount, file_index);
+  DCHECK_GE(file_index, 0);
+  DCHECK_LT(file_index, disk_cache::kSimpleEntryFileCount);
   return file_index == disk_cache::simple_util::GetFileIndexFromStreamIndex(2);
 }
 
@@ -284,7 +285,7 @@
   int file_index = GetFileIndexFromStreamIndex(in_entry_op.index);
   // Zero-length reads and reads to the empty streams of omitted files should
   // be handled in the SimpleEntryImpl.
-  DCHECK_LT(0, in_entry_op.buf_len);
+  DCHECK_GT(in_entry_op.buf_len, 0);
   DCHECK(!empty_file_omitted_[file_index]);
   File* file = const_cast<File*>(&files_[file_index]);
   int bytes_read =
@@ -408,19 +409,17 @@
     SparseRange* found_range = &it->second;
     DCHECK_EQ(it->first, found_range->offset);
     if (found_range->offset + found_range->length > offset) {
-      DCHECK_LE(0, found_range->length);
-      DCHECK_GE(kint32max, found_range->length);
-      DCHECK_LE(0, offset - found_range->offset);
-      DCHECK_GE(kint32max, offset - found_range->offset);
-      int range_len_after_offset = found_range->length -
-                                   (offset - found_range->offset);
-      DCHECK_LE(0, range_len_after_offset);
+      DCHECK_GE(found_range->length, 0);
+      DCHECK_LE(found_range->length, kint32max);
+      DCHECK_GE(offset - found_range->offset, 0);
+      DCHECK_LE(offset - found_range->offset, kint32max);
+      int net_offset = static_cast<int>(offset - found_range->offset);
+      int range_len_after_offset =
+          static_cast<int>(found_range->length - net_offset);
+      DCHECK_GE(range_len_after_offset, 0);
 
       int len_to_read = std::min(buf_len, range_len_after_offset);
-      if (!ReadSparseRange(found_range,
-                           offset - found_range->offset,
-                           len_to_read,
-                           buf)) {
+      if (!ReadSparseRange(found_range, net_offset, len_to_read, buf)) {
         *out_result = net::ERR_CACHE_READ_FAILURE;
         return;
       }
@@ -436,8 +435,7 @@
          it->second.offset == offset + read_so_far) {
     SparseRange* found_range = &it->second;
     DCHECK_EQ(it->first, found_range->offset);
-    int range_len = (found_range->length > kint32max) ?
-                    kint32max : found_range->length;
+    int range_len = base::saturated_cast<int>(found_range->length);
     int len_to_read = std::min(buf_len - read_so_far, range_len);
     if (!ReadSparseRange(found_range, 0, len_to_read, buf + read_so_far)) {
       *out_result = net::ERR_CACHE_READ_FAILURE;
@@ -484,19 +482,17 @@
     --it;
     SparseRange* found_range = &it->second;
     if (found_range->offset + found_range->length > offset) {
-      DCHECK_LE(0, found_range->length);
-      DCHECK_GE(kint32max, found_range->length);
-      DCHECK_LE(0, offset - found_range->offset);
-      DCHECK_GE(kint32max, offset - found_range->offset);
-      int range_len_after_offset = found_range->length -
-                                   (offset - found_range->offset);
-      DCHECK_LE(0, range_len_after_offset);
+      DCHECK_GE(found_range->length, 0);
+      DCHECK_LE(found_range->length, kint32max);
+      DCHECK_GE(offset - found_range->offset, 0);
+      DCHECK_LE(offset - found_range->offset, kint32max);
+      int net_offset = static_cast<int>(offset - found_range->offset);
+      int range_len_after_offset =
+          static_cast<int>(found_range->length - net_offset);
+      DCHECK_GE(range_len_after_offset, 0);
 
       int len_to_write = std::min(buf_len, range_len_after_offset);
-      if (!WriteSparseRange(found_range,
-                            offset - found_range->offset,
-                            len_to_write,
-                            buf)) {
+      if (!WriteSparseRange(found_range, net_offset, len_to_write, buf)) {
         *out_result = net::ERR_CACHE_WRITE_FAILURE;
         return;
       }
@@ -510,7 +506,8 @@
          it->second.offset < offset + buf_len) {
     SparseRange* found_range = &it->second;
     if (offset + written_so_far < found_range->offset) {
-      int len_to_append = found_range->offset - (offset + written_so_far);
+      int len_to_append =
+          static_cast<int>(found_range->offset - (offset + written_so_far));
       if (!AppendSparseRange(offset + written_so_far,
                              len_to_append,
                              buf + written_so_far)) {
@@ -520,8 +517,7 @@
       written_so_far += len_to_append;
       appended_so_far += len_to_append;
     }
-    int range_len = (found_range->length > kint32max) ?
-                    kint32max : found_range->length;
+    int range_len = base::saturated_cast<int>(found_range->length);
     int len_to_write = std::min(buf_len - written_so_far, range_len);
     if (!WriteSparseRange(found_range,
                           0,
@@ -567,7 +563,7 @@
   SparseRangeIterator it = sparse_ranges_.lower_bound(offset);
 
   int64 start = offset;
-  int avail_so_far = 0;
+  int64 avail_so_far = 0;
 
   if (it != sparse_ranges_.end() && it->second.offset < offset + len)
     start = it->second.offset;
@@ -589,9 +585,9 @@
     ++it;
   }
 
-  int len_from_start = len - (start - offset);
+  int64 len_from_start = len - (start - offset);
   *out_start = start;
-  *out_result = std::min(avail_so_far, len_from_start);
+  *out_result = static_cast<int>(std::min(avail_so_far, len_from_start));
 }
 
 void SimpleSynchronousEntry::CheckEOFRecord(int index,
@@ -680,7 +676,8 @@
     const int64 cluster_loss = file_size % 4096 ? 4096 - file_size % 4096 : 0;
     SIMPLE_CACHE_UMA(PERCENTAGE,
                      "LastClusterLossPercent", cache_type_,
-                     cluster_loss * 100 / (cluster_loss + file_size));
+                     static_cast<base::HistogramBase::Sample>(
+                         cluster_loss * 100 / (cluster_loss + file_size)));
   }
 
   if (sparse_file_open())
@@ -825,7 +822,7 @@
     // 0, stream 1 and one EOF record. The exact distribution of sizes between
     // stream 1 and stream 0 is only determined after reading the EOF record
     // for stream 0 in ReadAndValidateStream0.
-    out_entry_stat->set_data_size(i + 1, file_info.size);
+    out_entry_stat->set_data_size(i + 1, static_cast<int>(file_info.size));
   }
   SIMPLE_CACHE_UMA(CUSTOM_COUNTS,
                    "SyncOpenEntryAge", cache_type_,
@@ -1159,7 +1156,7 @@
 
 void SimpleSynchronousEntry::RecordSyncCreateResult(CreateEntryResult result,
                                                     bool had_index) {
-  DCHECK_GT(CREATE_ENTRY_MAX, result);
+  DCHECK_LT(result, CREATE_ENTRY_MAX);
   SIMPLE_CACHE_UMA(ENUMERATION,
                    "SyncCreateResult", cache_type_, result, CREATE_ENTRY_MAX);
   if (had_index) {
@@ -1256,7 +1253,7 @@
 bool SimpleSynchronousEntry::ScanSparseFile(int32* out_sparse_data_size) {
   DCHECK(sparse_file_open());
 
-  int32 sparse_data_size = 0;
+  int64 sparse_data_size = 0;
 
   SimpleFileHeader header;
   int header_read_result =
@@ -1307,11 +1304,11 @@
 
     range_header_offset += sizeof(range_header) + range.length;
 
-    DCHECK_LE(sparse_data_size, sparse_data_size + range.length);
+    DCHECK_GE(sparse_data_size + range.length, sparse_data_size);
     sparse_data_size += range.length;
   }
 
-  *out_sparse_data_size = sparse_data_size;
+  *out_sparse_data_size = static_cast<int32>(sparse_data_size);
   sparse_tail_offset_ = range_header_offset;
 
   return true;
@@ -1321,8 +1318,8 @@
                                              int offset, int len, char* buf) {
   DCHECK(range);
   DCHECK(buf);
-  DCHECK_GE(range->length, offset);
-  DCHECK_GE(range->length, offset + len);
+  DCHECK_LE(offset, range->length);
+  DCHECK_LE(offset + len, range->length);
 
   int bytes_read = sparse_file_.Read(range->file_offset + offset, buf, len);
   if (bytes_read < len) {
@@ -1350,8 +1347,8 @@
                                               const char* buf) {
   DCHECK(range);
   DCHECK(buf);
-  DCHECK_GE(range->length, offset);
-  DCHECK_GE(range->length, offset + len);
+  DCHECK_LE(offset, range->length);
+  DCHECK_LE(offset + len, range->length);
 
   uint32 new_crc32 = 0;
   if (offset == 0 && len == range->length) {
@@ -1390,8 +1387,8 @@
 bool SimpleSynchronousEntry::AppendSparseRange(int64 offset,
                                                int len,
                                                const char* buf) {
-  DCHECK_LE(0, offset);
-  DCHECK_LT(0, len);
+  DCHECK_GE(offset, 0);
+  DCHECK_GT(len, 0);
   DCHECK(buf);
 
   uint32 data_crc32 = crc32(crc32(0L, Z_NULL, 0),
diff --git a/net/disk_cache/simple/simple_util.cc b/net/disk_cache/simple/simple_util.cc
index 844b695..55f309e 100644
--- a/net/disk_cache/simple/simple_util.cc
+++ b/net/disk_cache/simple/simple_util.cc
@@ -9,6 +9,7 @@
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ -97,8 +98,7 @@
 int32 GetDataSizeFromKeyAndFileSize(const std::string& key, int64 file_size) {
   int64 data_size = file_size - key.size() - sizeof(SimpleFileHeader) -
                     sizeof(SimpleFileEOF);
-  DCHECK_GE(implicit_cast<int64>(std::numeric_limits<int32>::max()), data_size);
-  return data_size;
+  return base::checked_cast<int32>(data_size);
 }
 
 int64 GetFileSizeFromKeyAndDataSize(const std::string& key, int32 data_size) {
diff --git a/net/dns/address_sorter_posix.h b/net/dns/address_sorter_posix.h
index 1c88ad2..ce3ffdb 100644
--- a/net/dns/address_sorter_posix.h
+++ b/net/dns/address_sorter_posix.h
@@ -65,13 +65,13 @@
 
   // AddressSorter:
   virtual void Sort(const AddressList& list,
-                    const CallbackType& callback) const OVERRIDE;
+                    const CallbackType& callback) const override;
 
  private:
   friend class AddressSorterPosixTest;
 
   // NetworkChangeNotifier::IPAddressObserver:
-  virtual void OnIPAddressChanged() OVERRIDE;
+  virtual void OnIPAddressChanged() override;
 
   // Fills |info| with values for |address| from policy tables.
   void FillPolicy(const IPAddressNumber& address,
diff --git a/net/dns/address_sorter_posix_unittest.cc b/net/dns/address_sorter_posix_unittest.cc
index dea7ade..9039850 100644
--- a/net/dns/address_sorter_posix_unittest.cc
+++ b/net/dns/address_sorter_posix_unittest.cc
@@ -35,34 +35,34 @@
 
   virtual ~TestUDPClientSocket() {}
 
-  virtual int Read(IOBuffer*, int, const CompletionCallback&) OVERRIDE {
+  virtual int Read(IOBuffer*, int, const CompletionCallback&) override {
     NOTIMPLEMENTED();
     return OK;
   }
-  virtual int Write(IOBuffer*, int, const CompletionCallback&) OVERRIDE {
+  virtual int Write(IOBuffer*, int, const CompletionCallback&) override {
     NOTIMPLEMENTED();
     return OK;
   }
-  virtual int SetReceiveBufferSize(int32) OVERRIDE {
+  virtual int SetReceiveBufferSize(int32) override {
     return OK;
   }
-  virtual int SetSendBufferSize(int32) OVERRIDE {
+  virtual int SetSendBufferSize(int32) override {
     return OK;
   }
 
-  virtual void Close() OVERRIDE {}
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual void Close() override {}
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     NOTIMPLEMENTED();
     return OK;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     if (!connected_)
       return ERR_UNEXPECTED;
     *address = local_endpoint_;
     return OK;
   }
 
-  virtual int Connect(const IPEndPoint& remote) OVERRIDE {
+  virtual int Connect(const IPEndPoint& remote) override {
     if (connected_)
       return ERR_UNEXPECTED;
     AddressMapping::const_iterator it = mapping_->find(remote.address());
@@ -73,7 +73,7 @@
     return OK;
   }
 
-  virtual const BoundNetLog& NetLog() const OVERRIDE {
+  virtual const BoundNetLog& NetLog() const override {
     return net_log_;
   }
 
@@ -96,13 +96,13 @@
       DatagramSocket::BindType,
       const RandIntCallback&,
       NetLog*,
-      const NetLog::Source&) OVERRIDE {
+      const NetLog::Source&) override {
     return scoped_ptr<DatagramClientSocket>(new TestUDPClientSocket(&mapping_));
   }
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList&,
       NetLog*,
-      const NetLog::Source&) OVERRIDE {
+      const NetLog::Source&) override {
     NOTIMPLEMENTED();
     return scoped_ptr<StreamSocket>();
   }
@@ -110,11 +110,11 @@
       scoped_ptr<ClientSocketHandle>,
       const HostPortPair&,
       const SSLConfig&,
-      const SSLClientSocketContext&) OVERRIDE {
+      const SSLClientSocketContext&) override {
     NOTIMPLEMENTED();
     return scoped_ptr<SSLClientSocket>();
   }
-  virtual void ClearSSLSessionCache() OVERRIDE {
+  virtual void ClearSSLSessionCache() override {
     NOTIMPLEMENTED();
   }
 
diff --git a/net/dns/address_sorter_win.cc b/net/dns/address_sorter_win.cc
index 813bd93..079ba6a 100644
--- a/net/dns/address_sorter_win.cc
+++ b/net/dns/address_sorter_win.cc
@@ -31,7 +31,7 @@
 
   // AddressSorter:
   virtual void Sort(const AddressList& list,
-                    const CallbackType& callback) const OVERRIDE {
+                    const CallbackType& callback) const override {
     DCHECK(!list.empty());
     scoped_refptr<Job> job = new Job(list, callback);
   }
@@ -160,7 +160,7 @@
 
   // AddressSorter:
   virtual void Sort(const AddressList& list,
-                    const CallbackType& callback) const OVERRIDE {
+                    const CallbackType& callback) const override {
     AddressList list_ipv4;
     AddressList list_ipv6;
     for (size_t i = 0; i < list.size(); ++i) {
diff --git a/net/dns/dns_client.cc b/net/dns/dns_client.cc
index 9e29ca4..de96c02 100644
--- a/net/dns/dns_client.cc
+++ b/net/dns/dns_client.cc
@@ -24,7 +24,7 @@
       : address_sorter_(AddressSorter::CreateAddressSorter()),
         net_log_(net_log) {}
 
-  virtual void SetConfig(const DnsConfig& config) OVERRIDE {
+  virtual void SetConfig(const DnsConfig& config) override {
     factory_.reset();
     session_ = NULL;
     if (config.IsValid() && !config.unhandled_options) {
@@ -40,15 +40,15 @@
     }
   }
 
-  virtual const DnsConfig* GetConfig() const OVERRIDE {
+  virtual const DnsConfig* GetConfig() const override {
     return session_.get() ? &session_->config() : NULL;
   }
 
-  virtual DnsTransactionFactory* GetTransactionFactory() OVERRIDE {
+  virtual DnsTransactionFactory* GetTransactionFactory() override {
     return session_.get() ? factory_.get() : NULL;
   }
 
-  virtual AddressSorter* GetAddressSorter() OVERRIDE {
+  virtual AddressSorter* GetAddressSorter() override {
     return address_sorter_.get();
   }
 
diff --git a/net/dns/dns_config_service_posix.cc b/net/dns/dns_config_service_posix.cc
index 2c298dd..c0664eb 100644
--- a/net/dns/dns_config_service_posix.cc
+++ b/net/dns/dns_config_service_posix.cc
@@ -74,7 +74,7 @@
   }
 
   virtual void OnNetworkChanged(NetworkChangeNotifier::ConnectionType type)
-      OVERRIDE {
+      override {
     if (!callback_.is_null() && type != NetworkChangeNotifier::CONNECTION_NONE)
       callback_.Run(true);
   }
@@ -263,7 +263,7 @@
   explicit ConfigReader(DnsConfigServicePosix* service)
       : service_(service), success_(false) {}
 
-  virtual void DoWork() OVERRIDE {
+  virtual void DoWork() override {
     base::TimeTicks start_time = base::TimeTicks::Now();
     ConfigParsePosixResult result = ReadDnsConfig(&dns_config_);
     switch (result) {
@@ -285,7 +285,7 @@
                         base::TimeTicks::Now() - start_time);
   }
 
-  virtual void OnWorkFinished() OVERRIDE {
+  virtual void OnWorkFinished() override {
     DCHECK(!IsCancelled());
     if (success_) {
       service_->OnConfigRead(dns_config_);
@@ -314,7 +314,7 @@
  private:
   virtual ~HostsReader() {}
 
-  virtual void DoWork() OVERRIDE {
+  virtual void DoWork() override {
     base::TimeTicks start_time = base::TimeTicks::Now();
     success_ = ParseHostsFile(path_, &hosts_);
     UMA_HISTOGRAM_BOOLEAN("AsyncDNS.HostParseResult", success_);
@@ -322,7 +322,7 @@
                         base::TimeTicks::Now() - start_time);
   }
 
-  virtual void OnWorkFinished() OVERRIDE {
+  virtual void OnWorkFinished() override {
     if (success_) {
       service_->OnHostsRead(hosts_);
     } else {
diff --git a/net/dns/dns_config_service_posix.h b/net/dns/dns_config_service_posix.h
index ef28154..598d6ad 100644
--- a/net/dns/dns_config_service_posix.h
+++ b/net/dns/dns_config_service_posix.h
@@ -27,8 +27,8 @@
 
  protected:
   // DnsConfigService:
-  virtual void ReadNow() OVERRIDE;
-  virtual bool StartWatching() OVERRIDE;
+  virtual void ReadNow() override;
+  virtual bool StartWatching() override;
 
  private:
   class Watcher;
diff --git a/net/dns/dns_config_service_unittest.cc b/net/dns/dns_config_service_unittest.cc
index e71baef..0239f80 100644
--- a/net/dns/dns_config_service_unittest.cc
+++ b/net/dns/dns_config_service_unittest.cc
@@ -121,8 +121,8 @@
  protected:
   class TestDnsConfigService : public DnsConfigService {
    public:
-    virtual void ReadNow() OVERRIDE {}
-    virtual bool StartWatching() OVERRIDE { return true; }
+    virtual void ReadNow() override {}
+    virtual bool StartWatching() override { return true; }
 
     // Expose the protected methods to this test suite.
     void InvalidateConfig() {
@@ -176,7 +176,7 @@
     return hosts;
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     quit_on_config_ = false;
 
     service_.reset(new TestDnsConfigService());
diff --git a/net/dns/dns_config_service_win.cc b/net/dns/dns_config_service_win.cc
index ec7e6f2..dd3ee3d 100644
--- a/net/dns/dns_config_service_win.cc
+++ b/net/dns/dns_config_service_win.cc
@@ -312,7 +312,7 @@
     return true;
   }
 
-  virtual void OnObjectSignaled(HANDLE object) OVERRIDE {
+  virtual void OnObjectSignaled(HANDLE object) override {
     // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
     tracked_objects::ScopedProfile tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION(
@@ -609,7 +609,7 @@
   }
 
   // NetworkChangeNotifier::IPAddressObserver:
-  virtual void OnIPAddressChanged() OVERRIDE {
+  virtual void OnIPAddressChanged() override {
     // Need to update non-loopback IP of local host.
     service_->OnHostsChanged(true);
   }
@@ -635,7 +635,7 @@
  private:
   virtual ~ConfigReader() {}
 
-  virtual void DoWork() OVERRIDE {
+  virtual void DoWork() override {
     // Should be called on WorkerPool.
     base::TimeTicks start_time = base::TimeTicks::Now();
     DnsSystemSettings settings = {};
@@ -651,7 +651,7 @@
                         base::TimeTicks::Now() - start_time);
   }
 
-  virtual void OnWorkFinished() OVERRIDE {
+  virtual void OnWorkFinished() override {
     DCHECK(loop()->BelongsToCurrentThread());
     DCHECK(!IsCancelled());
     if (success_) {
@@ -685,7 +685,7 @@
  private:
   virtual ~HostsReader() {}
 
-  virtual void DoWork() OVERRIDE {
+  virtual void DoWork() override {
     base::TimeTicks start_time = base::TimeTicks::Now();
     HostsParseWinResult result = HOSTS_PARSE_WIN_UNREADABLE_HOSTS_FILE;
     if (ParseHostsFile(path_, &hosts_))
@@ -698,7 +698,7 @@
                         base::TimeTicks::Now() - start_time);
   }
 
-  virtual void OnWorkFinished() OVERRIDE {
+  virtual void OnWorkFinished() override {
     DCHECK(loop()->BelongsToCurrentThread());
     if (success_) {
       service_->OnHostsRead(hosts_);
diff --git a/net/dns/dns_config_service_win.h b/net/dns/dns_config_service_win.h
index d26aed5..c28d863 100644
--- a/net/dns/dns_config_service_win.h
+++ b/net/dns/dns_config_service_win.h
@@ -125,8 +125,8 @@
   class HostsReader;
 
   // DnsConfigService:
-  virtual void ReadNow() OVERRIDE;
-  virtual bool StartWatching() OVERRIDE;
+  virtual void ReadNow() override;
+  virtual bool StartWatching() override;
 
   void OnConfigChanged(bool succeeded);
   void OnHostsChanged(bool succeeded);
diff --git a/net/dns/dns_session_unittest.cc b/net/dns/dns_session_unittest.cc
index ed726f2..e6f1230 100644
--- a/net/dns/dns_session_unittest.cc
+++ b/net/dns/dns_session_unittest.cc
@@ -30,11 +30,11 @@
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       net::NetLog* net_log,
-      const net::NetLog::Source& source) OVERRIDE;
+      const net::NetLog::Source& source) override;
 
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
-      NetLog*, const NetLog::Source&) OVERRIDE {
+      NetLog*, const NetLog::Source&) override {
     NOTIMPLEMENTED();
     return scoped_ptr<StreamSocket>();
   }
@@ -43,12 +43,12 @@
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE {
+      const SSLClientSocketContext& context) override {
     NOTIMPLEMENTED();
     return scoped_ptr<SSLClientSocket>();
   }
 
-  virtual void ClearSSLSessionCache() OVERRIDE {
+  virtual void ClearSSLSessionCache() override {
     NOTIMPLEMENTED();
   }
 
@@ -92,19 +92,19 @@
 
   virtual void Initialize(
       const std::vector<IPEndPoint>* nameservers,
-      NetLog* net_log) OVERRIDE {
+      NetLog* net_log) override {
     InitializeInternal(nameservers, net_log);
   }
 
   virtual scoped_ptr<DatagramClientSocket> AllocateSocket(
-      unsigned server_index) OVERRIDE {
+      unsigned server_index) override {
     test_->OnSocketAllocated(server_index);
     return CreateConnectedSocket(server_index);
   }
 
   virtual void FreeSocket(
       unsigned server_index,
-      scoped_ptr<DatagramClientSocket> socket) OVERRIDE {
+      scoped_ptr<DatagramClientSocket> socket) override {
     test_->OnSocketFreed(server_index);
   }
 
diff --git a/net/dns/dns_socket_pool.cc b/net/dns/dns_socket_pool.cc
index b446fa0..09aca5a 100644
--- a/net/dns/dns_socket_pool.cc
+++ b/net/dns/dns_socket_pool.cc
@@ -97,18 +97,18 @@
 
   virtual void Initialize(
       const std::vector<IPEndPoint>* nameservers,
-      NetLog* net_log) OVERRIDE {
+      NetLog* net_log) override {
     InitializeInternal(nameservers, net_log);
   }
 
   virtual scoped_ptr<DatagramClientSocket> AllocateSocket(
-      unsigned server_index) OVERRIDE {
+      unsigned server_index) override {
     return CreateConnectedSocket(server_index);
   }
 
   virtual void FreeSocket(
       unsigned server_index,
-      scoped_ptr<DatagramClientSocket> socket) OVERRIDE {
+      scoped_ptr<DatagramClientSocket> socket) override {
   }
 
  private:
@@ -131,14 +131,14 @@
 
   virtual void Initialize(
       const std::vector<IPEndPoint>* nameservers,
-      NetLog* net_log) OVERRIDE;
+      NetLog* net_log) override;
 
   virtual scoped_ptr<DatagramClientSocket> AllocateSocket(
-      unsigned server_index) OVERRIDE;
+      unsigned server_index) override;
 
   virtual void FreeSocket(
       unsigned server_index,
-      scoped_ptr<DatagramClientSocket> socket) OVERRIDE;
+      scoped_ptr<DatagramClientSocket> socket) override;
 
  private:
   void FillPool(unsigned server_index, unsigned size);
diff --git a/net/dns/dns_test_util.cc b/net/dns/dns_test_util.cc
index 01acb34..6327ed2 100644
--- a/net/dns/dns_test_util.cc
+++ b/net/dns/dns_test_util.cc
@@ -27,7 +27,7 @@
  public:
   virtual ~MockAddressSorter() {}
   virtual void Sort(const AddressList& list,
-                    const CallbackType& callback) const OVERRIDE {
+                    const CallbackType& callback) const override {
     // Do nothing.
     callback.Run(true, list);
   }
@@ -60,15 +60,15 @@
     }
   }
 
-  virtual const std::string& GetHostname() const OVERRIDE {
+  virtual const std::string& GetHostname() const override {
     return hostname_;
   }
 
-  virtual uint16 GetType() const OVERRIDE {
+  virtual uint16 GetType() const override {
     return qtype_;
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     EXPECT_FALSE(started_);
     started_ = true;
     if (delayed_)
@@ -172,7 +172,7 @@
       const std::string& hostname,
       uint16 qtype,
       const DnsTransactionFactory::CallbackType& callback,
-      const BoundNetLog&) OVERRIDE {
+      const BoundNetLog&) override {
     MockTransaction* transaction =
         new MockTransaction(rules_, hostname, qtype, callback);
     if (transaction->delayed())
diff --git a/net/dns/dns_test_util.h b/net/dns/dns_test_util.h
index d0b8e81..5b363c7 100644
--- a/net/dns/dns_test_util.h
+++ b/net/dns/dns_test_util.h
@@ -211,10 +211,10 @@
   virtual ~MockDnsClient();
 
   // DnsClient interface:
-  virtual void SetConfig(const DnsConfig& config) OVERRIDE;
-  virtual const DnsConfig* GetConfig() const OVERRIDE;
-  virtual DnsTransactionFactory* GetTransactionFactory() OVERRIDE;
-  virtual AddressSorter* GetAddressSorter() OVERRIDE;
+  virtual void SetConfig(const DnsConfig& config) override;
+  virtual const DnsConfig* GetConfig() const override;
+  virtual DnsTransactionFactory* GetTransactionFactory() override;
+  virtual AddressSorter* GetAddressSorter() override;
 
   // Completes all DnsTransactions that were delayed by a rule.
   void CompleteDelayedTransactions();
diff --git a/net/dns/dns_transaction.cc b/net/dns/dns_transaction.cc
index 0424d48..32b5602 100644
--- a/net/dns/dns_transaction.cc
+++ b/net/dns/dns_transaction.cc
@@ -141,7 +141,7 @@
         query_(query.Pass()) {}
 
   // DnsAttempt:
-  virtual int Start(const CompletionCallback& callback) OVERRIDE {
+  virtual int Start(const CompletionCallback& callback) override {
     DCHECK_EQ(STATE_NONE, next_state_);
     callback_ = callback;
     start_time_ = base::TimeTicks::Now();
@@ -149,16 +149,16 @@
     return DoLoop(OK);
   }
 
-  virtual const DnsQuery* GetQuery() const OVERRIDE {
+  virtual const DnsQuery* GetQuery() const override {
     return query_.get();
   }
 
-  virtual const DnsResponse* GetResponse() const OVERRIDE {
+  virtual const DnsResponse* GetResponse() const override {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
-  virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
+  virtual const BoundNetLog& GetSocketNetLog() const override {
     return socket_lease_->socket()->NetLog();
   }
 
@@ -306,7 +306,7 @@
         response_length_(0) {}
 
   // DnsAttempt:
-  virtual int Start(const CompletionCallback& callback) OVERRIDE {
+  virtual int Start(const CompletionCallback& callback) override {
     DCHECK_EQ(STATE_NONE, next_state_);
     callback_ = callback;
     start_time_ = base::TimeTicks::Now();
@@ -320,16 +320,16 @@
     return DoLoop(rv);
   }
 
-  virtual const DnsQuery* GetQuery() const OVERRIDE {
+  virtual const DnsQuery* GetQuery() const override {
     return query_.get();
   }
 
-  virtual const DnsResponse* GetResponse() const OVERRIDE {
+  virtual const DnsResponse* GetResponse() const override {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
-  virtual const BoundNetLog& GetSocketNetLog() const OVERRIDE {
+  virtual const BoundNetLog& GetSocketNetLog() const override {
     return socket_->NetLog();
   }
 
@@ -574,17 +574,17 @@
     }  // otherwise logged in DoCallback or Start
   }
 
-  virtual const std::string& GetHostname() const OVERRIDE {
+  virtual const std::string& GetHostname() const override {
     DCHECK(CalledOnValidThread());
     return hostname_;
   }
 
-  virtual uint16 GetType() const OVERRIDE {
+  virtual uint16 GetType() const override {
     DCHECK(CalledOnValidThread());
     return qtype_;
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DCHECK(!callback_.is_null());
     DCHECK(attempts_.empty());
     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION,
@@ -972,7 +972,7 @@
       const std::string& hostname,
       uint16 qtype,
       const CallbackType& callback,
-      const BoundNetLog& net_log) OVERRIDE {
+      const BoundNetLog& net_log) override {
     return scoped_ptr<DnsTransaction>(new DnsTransactionImpl(
         session_.get(), hostname, qtype, callback, net_log));
   }
diff --git a/net/dns/dns_transaction_unittest.cc b/net/dns/dns_transaction_unittest.cc
index af073ac..908f915 100644
--- a/net/dns/dns_transaction_unittest.cc
+++ b/net/dns/dns_transaction_unittest.cc
@@ -153,7 +153,7 @@
       : MockUDPClientSocket(data, net_log) {
   }
   virtual ~FailingUDPClientSocket() {}
-  virtual int Connect(const IPEndPoint& endpoint) OVERRIDE {
+  virtual int Connect(const IPEndPoint& endpoint) override {
     return ERR_CONNECTION_REFUSED;
   }
 
@@ -170,7 +170,7 @@
       : MockUDPClientSocket(data, net_log), factory_(factory) {
   }
   virtual ~TestUDPClientSocket() {}
-  virtual int Connect(const IPEndPoint& endpoint) OVERRIDE;
+  virtual int Connect(const IPEndPoint& endpoint) override;
 
  private:
   TestSocketFactory* factory_;
@@ -188,7 +188,7 @@
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       net::NetLog* net_log,
-      const net::NetLog::Source& source) OVERRIDE {
+      const net::NetLog::Source& source) override {
     if (fail_next_socket_) {
       fail_next_socket_ = false;
       return scoped_ptr<DatagramClientSocket>(
@@ -441,7 +441,7 @@
     }
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // By default set one server,
     ConfigureNumServers(1);
     // and no retransmissions,
@@ -451,7 +451,7 @@
     ConfigureFactory();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Check that all socket data was at least written to.
     for (size_t i = 0; i < socket_data_.size(); ++i) {
       EXPECT_TRUE(socket_data_[i]->was_written()) << i;
diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
index 201bba4..5632ef9 100644
--- a/net/dns/host_resolver_impl.cc
+++ b/net/dns/host_resolver_impl.cc
@@ -1424,7 +1424,7 @@
   }
 
   // PriorityDispatch::Job:
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DCHECK_LE(num_occupied_job_slots_, 1u);
 
     handle_.Reset();
@@ -1590,7 +1590,7 @@
   virtual void OnDnsTaskComplete(base::TimeTicks start_time,
                                  int net_error,
                                  const AddressList& addr_list,
-                                 base::TimeDelta ttl) OVERRIDE {
+                                 base::TimeDelta ttl) override {
     DCHECK(is_dns_running());
 
     base::TimeDelta duration = base::TimeTicks::Now() - start_time;
@@ -1625,7 +1625,7 @@
         bounded_ttl);
   }
 
-  virtual void OnFirstDnsTransactionComplete() OVERRIDE {
+  virtual void OnFirstDnsTransactionComplete() override {
     DCHECK(dns_task_->needs_two_transactions());
     DCHECK_EQ(dns_task_->needs_another_transaction(), is_queued());
     // No longer need to occupy two dispatcher slots.
diff --git a/net/dns/host_resolver_impl.h b/net/dns/host_resolver_impl.h
index 7a0fb57..edd64fc 100644
--- a/net/dns/host_resolver_impl.h
+++ b/net/dns/host_resolver_impl.h
@@ -129,16 +129,16 @@
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& source_net_log) OVERRIDE;
+                      const BoundNetLog& source_net_log) override;
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& source_net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle req) OVERRIDE;
-  virtual void SetDefaultAddressFamily(AddressFamily address_family) OVERRIDE;
-  virtual AddressFamily GetDefaultAddressFamily() const OVERRIDE;
-  virtual void SetDnsClientEnabled(bool enabled) OVERRIDE;
-  virtual HostCache* GetHostCache() OVERRIDE;
-  virtual base::Value* GetDnsConfigAsValue() const OVERRIDE;
+                               const BoundNetLog& source_net_log) override;
+  virtual void CancelRequest(RequestHandle req) override;
+  virtual void SetDefaultAddressFamily(AddressFamily address_family) override;
+  virtual AddressFamily GetDefaultAddressFamily() const override;
+  virtual void SetDnsClientEnabled(bool enabled) override;
+  virtual HostCache* GetHostCache() override;
+  virtual base::Value* GetDnsConfigAsValue() const override;
 
   void set_proc_params_for_test(const ProcTaskParams& proc_params) {
     proc_params_ = proc_params;
@@ -220,10 +220,10 @@
   void TryServingAllJobsFromHosts();
 
   // NetworkChangeNotifier::IPAddressObserver:
-  virtual void OnIPAddressChanged() OVERRIDE;
+  virtual void OnIPAddressChanged() override;
 
   // NetworkChangeNotifier::DNSObserver:
-  virtual void OnDNSChanged() OVERRIDE;
+  virtual void OnDNSChanged() override;
 
   // True if have a DnsClient with a valid DnsConfig.
   bool HaveDnsConfig() const;
diff --git a/net/dns/host_resolver_impl_unittest.cc b/net/dns/host_resolver_impl_unittest.cc
index 89112de..dadc03d 100644
--- a/net/dns/host_resolver_impl_unittest.cc
+++ b/net/dns/host_resolver_impl_unittest.cc
@@ -129,7 +129,7 @@
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) OVERRIDE {
+                      int* os_error) override {
     base::AutoLock lock(lock_);
     capture_list_.push_back(ResolveKey(hostname, address_family));
     ++num_requests_waiting_;
@@ -365,7 +365,7 @@
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) OVERRIDE {
+                      int* os_error) override {
     bool wait_for_right_attempt_to_complete = true;
     {
       base::AutoLock auto_lock(lock_);
@@ -460,11 +460,11 @@
   };
 
   // testing::Test implementation:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     CreateResolver();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (resolver_.get())
       EXPECT_EQ(0u, resolver_->num_running_dispatcher_jobs_for_tests());
     EXPECT_FALSE(proc_->HasBlockedRequests());
@@ -732,7 +732,7 @@
 
 TEST_F(HostResolverImplTest, CancelWithinCallback) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       // Port 80 is the first request that the callback will be invoked for.
       // While we are executing within that callback, cancel the other requests
       // in the job and start another request.
@@ -761,7 +761,7 @@
 
 TEST_F(HostResolverImplTest, DeleteWithinCallback) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       EXPECT_EQ("a", req->info().hostname());
       EXPECT_EQ(80, req->info().port());
 
@@ -787,7 +787,7 @@
 
 TEST_F(HostResolverImplTest, DeleteWithinAbortedCallback) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       EXPECT_EQ("a", req->info().hostname());
       EXPECT_EQ(80, req->info().port());
 
@@ -827,7 +827,7 @@
 
 TEST_F(HostResolverImplTest, StartWithinCallback) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       if (req->index() == 0) {
         // On completing the first request, start another request for "a".
         // Since caching is disabled, this will result in another async request.
@@ -858,7 +858,7 @@
 
 TEST_F(HostResolverImplTest, BypassCache) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       if (req->index() == 0) {
         // On completing the first request, start another request for "a".
         // Since caching is enabled, this should complete synchronously.
@@ -956,7 +956,7 @@
 // will not be aborted.
 TEST_F(HostResolverImplTest, AbortOnlyExistingRequestsOnIPAddressChange) {
   struct MyHandler : public Handler {
-    virtual void Handle(Request* req) OVERRIDE {
+    virtual void Handle(Request* req) override {
       // Start new request for a different hostname to ensure that the order
       // of jobs in HostResolverImpl is not stable.
       std::string hostname;
@@ -1339,7 +1339,7 @@
 
  protected:
   // testing::Test implementation:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     AddDnsRule("nx", dns_protocol::kTypeA, MockDnsClientRule::FAIL, false);
     AddDnsRule("nx", dns_protocol::kTypeAAAA, MockDnsClientRule::FAIL, false);
     AddDnsRule("ok", dns_protocol::kTypeA, MockDnsClientRule::OK, false);
@@ -1381,7 +1381,7 @@
   // HostResolverImplTest implementation:
   virtual void CreateResolverWithLimitsAndParams(
       size_t max_concurrent_resolves,
-      const HostResolverImpl::ProcTaskParams& params) OVERRIDE {
+      const HostResolverImpl::ProcTaskParams& params) override {
     HostResolverImpl::Options options = DefaultOptions();
     options.max_concurrent_resolves = max_concurrent_resolves;
     resolver_.reset(new HostResolverImpl(options, NULL));
diff --git a/net/dns/host_resolver_proc.h b/net/dns/host_resolver_proc.h
index 014a720..695e3bc 100644
--- a/net/dns/host_resolver_proc.h
+++ b/net/dns/host_resolver_proc.h
@@ -99,7 +99,7 @@
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addr_list,
-                      int* os_error) OVERRIDE;
+                      int* os_error) override;
  protected:
   virtual ~SystemHostResolverProc();
 
diff --git a/net/dns/mapped_host_resolver.h b/net/dns/mapped_host_resolver.h
index c03a2a6..6d4ab92 100644
--- a/net/dns/mapped_host_resolver.h
+++ b/net/dns/mapped_host_resolver.h
@@ -50,14 +50,14 @@
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE;
+                      const BoundNetLog& net_log) override;
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle req) OVERRIDE;
-  virtual void SetDnsClientEnabled(bool enabled) OVERRIDE;
-  virtual HostCache* GetHostCache() OVERRIDE;
-  virtual base::Value* GetDnsConfigAsValue() const OVERRIDE;
+                               const BoundNetLog& net_log) override;
+  virtual void CancelRequest(RequestHandle req) override;
+  virtual void SetDnsClientEnabled(bool enabled) override;
+  virtual HostCache* GetHostCache() override;
+  virtual base::Value* GetDnsConfigAsValue() const override;
 
  private:
   // Modify the request |info| according to |rules_|. Returns either OK or
diff --git a/net/dns/mdns_client_impl.h b/net/dns/mdns_client_impl.h
index 6051511..b6f8b93 100644
--- a/net/dns/mdns_client_impl.h
+++ b/net/dns/mdns_client_impl.h
@@ -29,7 +29,7 @@
   virtual ~MDnsSocketFactoryImpl() {};
 
   virtual void CreateSockets(
-      ScopedVector<DatagramServerSocket>* sockets) OVERRIDE;
+      ScopedVector<DatagramServerSocket>* sockets) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MDnsSocketFactoryImpl);
@@ -128,9 +128,9 @@
                     std::vector<const RecordParsed*>* records) const;
 
     // Parse the response and alert relevant listeners.
-    virtual void HandlePacket(DnsResponse* response, int bytes_read) OVERRIDE;
+    virtual void HandlePacket(DnsResponse* response, int bytes_read) override;
 
-    virtual void OnConnectionError(int error) OVERRIDE;
+    virtual void OnConnectionError(int error) override;
 
    private:
     typedef std::pair<std::string, uint16> ListenerKey;
@@ -176,17 +176,17 @@
   virtual scoped_ptr<MDnsListener> CreateListener(
       uint16 rrtype,
       const std::string& name,
-      MDnsListener::Delegate* delegate) OVERRIDE;
+      MDnsListener::Delegate* delegate) override;
 
   virtual scoped_ptr<MDnsTransaction> CreateTransaction(
       uint16 rrtype,
       const std::string& name,
       int flags,
-      const MDnsTransaction::ResultCallback& callback) OVERRIDE;
+      const MDnsTransaction::ResultCallback& callback) override;
 
-  virtual bool StartListening(MDnsSocketFactory* socket_factory) OVERRIDE;
-  virtual void StopListening() OVERRIDE;
-  virtual bool IsListening() const OVERRIDE;
+  virtual bool StartListening(MDnsSocketFactory* socket_factory) override;
+  virtual void StopListening() override;
+  virtual bool IsListening() const override;
 
   Core* core() { return core_.get(); }
 
@@ -207,14 +207,14 @@
   virtual ~MDnsListenerImpl();
 
   // MDnsListener implementation:
-  virtual bool Start() OVERRIDE;
+  virtual bool Start() override;
 
   // Actively refresh any received records.
-  virtual void SetActiveRefresh(bool active_refresh) OVERRIDE;
+  virtual void SetActiveRefresh(bool active_refresh) override;
 
-  virtual const std::string& GetName() const OVERRIDE;
+  virtual const std::string& GetName() const override;
 
-  virtual uint16 GetType() const OVERRIDE;
+  virtual uint16 GetType() const override;
 
   MDnsListener::Delegate* delegate() { return delegate_; }
 
@@ -255,17 +255,17 @@
   virtual ~MDnsTransactionImpl();
 
   // MDnsTransaction implementation:
-  virtual bool Start() OVERRIDE;
+  virtual bool Start() override;
 
-  virtual const std::string& GetName() const OVERRIDE;
-  virtual uint16 GetType() const OVERRIDE;
+  virtual const std::string& GetName() const override;
+  virtual uint16 GetType() const override;
 
   // MDnsListener::Delegate implementation:
   virtual void OnRecordUpdate(MDnsListener::UpdateType update,
-                              const RecordParsed* record) OVERRIDE;
-  virtual void OnNsecRecord(const std::string& name, unsigned type) OVERRIDE;
+                              const RecordParsed* record) override;
+  virtual void OnNsecRecord(const std::string& name, unsigned type) override;
 
-  virtual void OnCachePurged() OVERRIDE;
+  virtual void OnCachePurged() override;
 
  private:
   bool is_active() { return !callback_.is_null(); }
diff --git a/net/dns/mdns_client_unittest.cc b/net/dns/mdns_client_unittest.cc
index a7a3c03..4b2e7d5 100644
--- a/net/dns/mdns_client_unittest.cc
+++ b/net/dns/mdns_client_unittest.cc
@@ -391,7 +391,7 @@
 
 class MDnsTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
   void DeleteTransaction();
   void DeleteBothListeners();
   void RunFor(base::TimeDelta time_period);
@@ -1057,7 +1057,7 @@
 class SimpleMockSocketFactory : public MDnsSocketFactory {
  public:
   virtual void CreateSockets(
-      ScopedVector<DatagramServerSocket>* sockets) OVERRIDE {
+      ScopedVector<DatagramServerSocket>* sockets) override {
     sockets->clear();
     sockets->swap(sockets_);
   }
@@ -1088,7 +1088,7 @@
 
  protected:
   // Follow successful connection initialization.
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     socket_ipv4_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV4);
     socket_ipv6_ = new MockMDnsDatagramServerSocket(ADDRESS_FAMILY_IPV6);
     factory_.PushSocket(socket_ipv6_);
@@ -1160,7 +1160,7 @@
 
 class MDnsConnectionSendTest : public MDnsConnectionTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     MDnsConnectionTest::SetUp();
     EXPECT_CALL(*socket_ipv4_, RecvFrom(_, _, _, _))
         .WillOnce(Return(ERR_IO_PENDING));
diff --git a/net/dns/mock_host_resolver.h b/net/dns/mock_host_resolver.h
index 3593fbd..9d5339f 100644
--- a/net/dns/mock_host_resolver.h
+++ b/net/dns/mock_host_resolver.h
@@ -79,12 +79,12 @@
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE;
+                      const BoundNetLog& net_log) override;
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle req) OVERRIDE;
-  virtual HostCache* GetHostCache() OVERRIDE;
+                               const BoundNetLog& net_log) override;
+  virtual void CancelRequest(RequestHandle req) override;
+  virtual HostCache* GetHostCache() override;
 
   // Resolves all pending requests. It is only valid to invoke this if
   // set_ondemand_mode was set before. The requests are resolved asynchronously,
@@ -206,7 +206,7 @@
                       AddressFamily address_family,
                       HostResolverFlags host_resolver_flags,
                       AddressList* addrlist,
-                      int* os_error) OVERRIDE;
+                      int* os_error) override;
 
  private:
   struct Rule;
@@ -228,11 +228,11 @@
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE;
+                      const BoundNetLog& net_log) override;
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle req) OVERRIDE {}
+                               const BoundNetLog& net_log) override;
+  virtual void CancelRequest(RequestHandle req) override {}
 };
 
 // This class sets the default HostResolverProc for a particular scope.  The
diff --git a/net/dns/mock_mdns_socket_factory.h b/net/dns/mock_mdns_socket_factory.h
index 1ecc4be..6278661 100644
--- a/net/dns/mock_mdns_socket_factory.h
+++ b/net/dns/mock_mdns_socket_factory.h
@@ -27,7 +27,7 @@
                              const CompletionCallback& callback));
 
   virtual int SendTo(IOBuffer* buf, int buf_len, const IPEndPoint& address,
-                     const CompletionCallback& callback) OVERRIDE;
+                     const CompletionCallback& callback) override;
 
   MOCK_METHOD3(SendToInternal, int(const std::string& packet,
                                    const std::string address,
@@ -39,7 +39,7 @@
   MOCK_METHOD0(Close, void());
 
   MOCK_CONST_METHOD1(GetPeerAddress, int(IPEndPoint* address));
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
   MOCK_CONST_METHOD0(NetLog, const BoundNetLog&());
 
   MOCK_METHOD0(AllowAddressReuse, void());
@@ -75,7 +75,7 @@
   virtual ~MockMDnsSocketFactory();
 
   virtual void CreateSockets(
-      ScopedVector<DatagramServerSocket>* sockets) OVERRIDE;
+      ScopedVector<DatagramServerSocket>* sockets) override;
 
   void SimulateReceive(const uint8* packet, int size);
 
diff --git a/net/dns/notify_watcher_mac.h b/net/dns/notify_watcher_mac.h
index 01375d5..0951c2f 100644
--- a/net/dns/notify_watcher_mac.h
+++ b/net/dns/notify_watcher_mac.h
@@ -31,8 +31,8 @@
 
  private:
   // MessageLoopForIO::Watcher:
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {}
+  virtual void OnFileCanReadWithoutBlocking(int fd) override;
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override {}
 
   int notify_fd_;
   int notify_token_;
diff --git a/net/dns/record_rdata.h b/net/dns/record_rdata.h
index def8e33..09a082f 100644
--- a/net/dns/record_rdata.h
+++ b/net/dns/record_rdata.h
@@ -48,8 +48,8 @@
   static scoped_ptr<SrvRecordRdata> Create(const base::StringPiece& data,
                                            const DnsRecordParser& parser);
 
-  virtual bool IsEqual(const RecordRdata* other) const OVERRIDE;
-  virtual uint16 Type() const OVERRIDE;
+  virtual bool IsEqual(const RecordRdata* other) const override;
+  virtual uint16 Type() const override;
 
   uint16 priority() const { return priority_; }
   uint16 weight() const { return weight_; }
@@ -78,8 +78,8 @@
   virtual ~ARecordRdata();
   static scoped_ptr<ARecordRdata> Create(const base::StringPiece& data,
                                          const DnsRecordParser& parser);
-  virtual bool IsEqual(const RecordRdata* other) const OVERRIDE;
-  virtual uint16 Type() const OVERRIDE;
+  virtual bool IsEqual(const RecordRdata* other) const override;
+  virtual uint16 Type() const override;
 
   const IPAddressNumber& address() const { return address_; }
 
@@ -100,8 +100,8 @@
   virtual ~AAAARecordRdata();
   static scoped_ptr<AAAARecordRdata> Create(const base::StringPiece& data,
                                          const DnsRecordParser& parser);
-  virtual bool IsEqual(const RecordRdata* other) const OVERRIDE;
-  virtual uint16 Type() const OVERRIDE;
+  virtual bool IsEqual(const RecordRdata* other) const override;
+  virtual uint16 Type() const override;
 
   const IPAddressNumber& address() const { return address_; }
 
@@ -122,8 +122,8 @@
   virtual ~CnameRecordRdata();
   static scoped_ptr<CnameRecordRdata> Create(const base::StringPiece& data,
                                              const DnsRecordParser& parser);
-  virtual bool IsEqual(const RecordRdata* other) const OVERRIDE;
-  virtual uint16 Type() const OVERRIDE;
+  virtual bool IsEqual(const RecordRdata* other) const override;
+  virtual uint16 Type() const override;
 
   std::string cname() const { return cname_; }
 
@@ -144,8 +144,8 @@
   virtual ~PtrRecordRdata();
   static scoped_ptr<PtrRecordRdata> Create(const base::StringPiece& data,
                                            const DnsRecordParser& parser);
-  virtual bool IsEqual(const RecordRdata* other) const OVERRIDE;
-  virtual uint16 Type() const OVERRIDE;
+  virtual bool IsEqual(const RecordRdata* other) const override;
+  virtual uint16 Type() const override;
 
   std::string ptrdomain() const { return ptrdomain_; }
 
@@ -167,8 +167,8 @@
   virtual ~TxtRecordRdata();
   static scoped_ptr<TxtRecordRdata> Create(const base::StringPiece& data,
                                            const DnsRecordParser& parser);
-  virtual bool IsEqual(const RecordRdata* other) const OVERRIDE;
-  virtual uint16 Type() const OVERRIDE;
+  virtual bool IsEqual(const RecordRdata* other) const override;
+  virtual uint16 Type() const override;
 
   const std::vector<std::string>& texts() const { return texts_; }
 
@@ -191,8 +191,8 @@
   virtual ~NsecRecordRdata();
   static scoped_ptr<NsecRecordRdata> Create(const base::StringPiece& data,
                                             const DnsRecordParser& parser);
-  virtual bool IsEqual(const RecordRdata* other) const OVERRIDE;
-  virtual uint16 Type() const OVERRIDE;
+  virtual bool IsEqual(const RecordRdata* other) const override;
+  virtual uint16 Type() const override;
 
   // Length of the bitmap in bits.
   unsigned bitmap_length() const { return bitmap_.size() * 8; }
diff --git a/net/dns/serial_worker_unittest.cc b/net/dns/serial_worker_unittest.cc
index 442526f..c670a75 100644
--- a/net/dns/serial_worker_unittest.cc
+++ b/net/dns/serial_worker_unittest.cc
@@ -21,11 +21,11 @@
    public:
     explicit TestSerialWorker(SerialWorkerTest* t)
       : test_(t) {}
-    virtual void DoWork() OVERRIDE {
+    virtual void DoWork() override {
       ASSERT_TRUE(test_);
       test_->OnWork();
     }
-    virtual void OnWorkFinished() OVERRIDE {
+    virtual void OnWorkFinished() override {
       ASSERT_TRUE(test_);
       test_->OnWorkFinished();
     }
@@ -96,12 +96,12 @@
   }
 
   // test::Test methods
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     message_loop_ = base::MessageLoop::current();
     worker_ = new TestSerialWorker(this);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Cancel the worker to catch if it makes a late DoWork call.
     worker_->Cancel();
     // Check if OnWork is stalled.
diff --git a/net/dns/single_request_host_resolver_unittest.cc b/net/dns/single_request_host_resolver_unittest.cc
index cc20bf3..7b09193 100644
--- a/net/dns/single_request_host_resolver_unittest.cc
+++ b/net/dns/single_request_host_resolver_unittest.cc
@@ -35,7 +35,7 @@
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE {
+                      const BoundNetLog& net_log) override {
     EXPECT_FALSE(has_outstanding_request());
     outstanding_request_ = reinterpret_cast<RequestHandle>(0x1234);
     *out_req = outstanding_request_;
@@ -47,12 +47,12 @@
 
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE {
+                               const BoundNetLog& net_log) override {
     NOTIMPLEMENTED();
     return ERR_UNEXPECTED;
   }
 
-  virtual void CancelRequest(RequestHandle req) OVERRIDE {
+  virtual void CancelRequest(RequestHandle req) override {
     EXPECT_TRUE(has_outstanding_request());
     EXPECT_EQ(req, outstanding_request_);
     outstanding_request_ = NULL;
diff --git a/net/extras/sqlite/sqlite_channel_id_store.h b/net/extras/sqlite/sqlite_channel_id_store.h
index 9d032a3..e743ba6 100644
--- a/net/extras/sqlite/sqlite_channel_id_store.h
+++ b/net/extras/sqlite/sqlite_channel_id_store.h
@@ -36,12 +36,12 @@
       const scoped_refptr<base::SequencedTaskRunner>& background_task_runner);
 
   // DefaultChannelIDStore::PersistentStore:
-  virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE;
+  virtual void Load(const LoadedCallback& loaded_callback) override;
   virtual void AddChannelID(
-      const DefaultChannelIDStore::ChannelID& channel_id) OVERRIDE;
+      const DefaultChannelIDStore::ChannelID& channel_id) override;
   virtual void DeleteChannelID(
-      const DefaultChannelIDStore::ChannelID& channel_id) OVERRIDE;
-  virtual void SetForceKeepSessionState() OVERRIDE;
+      const DefaultChannelIDStore::ChannelID& channel_id) override;
+  virtual void SetForceKeepSessionState() override;
 
   // Delete channel ids from servers in |server_identifiers|.
   void DeleteAllInList(const std::list<std::string>& server_identifiers);
diff --git a/net/filter/gzip_filter.h b/net/filter/gzip_filter.h
index 0ae284a..07b7821 100644
--- a/net/filter/gzip_filter.h
+++ b/net/filter/gzip_filter.h
@@ -49,7 +49,7 @@
   // return. For example, the internal zlib may process some pre-filter data
   // but not produce output yet.
   virtual FilterStatus ReadFilteredData(char* dest_buffer,
-                                        int* dest_len) OVERRIDE;
+                                        int* dest_len) override;
 
  private:
   enum DecodingStatus {
diff --git a/net/filter/mock_filter_context.h b/net/filter/mock_filter_context.h
index a68f456..bdef812 100644
--- a/net/filter/mock_filter_context.h
+++ b/net/filter/mock_filter_context.h
@@ -41,37 +41,37 @@
   // of those interfaces as coding errors.
   void NukeUnstableInterfaces();
 
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const override;
 
   // What URL was used to access this data?
   // Return false if gurl is not present.
-  virtual bool GetURL(GURL* gurl) const OVERRIDE;
+  virtual bool GetURL(GURL* gurl) const override;
 
   // What Content-Disposition did the server supply for this data?
   // Return false if Content-Disposition was not present.
-  virtual bool GetContentDisposition(std::string* disposition) const OVERRIDE;
+  virtual bool GetContentDisposition(std::string* disposition) const override;
 
   // What was this data requested from a server?
-  virtual base::Time GetRequestTime() const OVERRIDE;
+  virtual base::Time GetRequestTime() const override;
 
   // Is data supplied from cache, or fresh across the net?
-  virtual bool IsCachedContent() const OVERRIDE;
+  virtual bool IsCachedContent() const override;
 
   // Is this a download?
-  virtual bool IsDownload() const OVERRIDE;
+  virtual bool IsDownload() const override;
 
   // Was this data flagged as a response to a request with an SDCH dictionary?
-  virtual bool SdchResponseExpected() const OVERRIDE;
+  virtual bool SdchResponseExpected() const override;
 
   // How many bytes were fed to filter(s) so far?
-  virtual int64 GetByteReadCount() const OVERRIDE;
+  virtual int64 GetByteReadCount() const override;
 
-  virtual int GetResponseCode() const OVERRIDE;
+  virtual int GetResponseCode() const override;
 
   // The URLRequestContext associated with the request.
-  virtual const URLRequestContext* GetURLRequestContext() const OVERRIDE;
+  virtual const URLRequestContext* GetURLRequestContext() const override;
 
-  virtual void RecordPacketStats(StatisticSelector statistic) const OVERRIDE {}
+  virtual void RecordPacketStats(StatisticSelector statistic) const override {}
 
  private:
   int buffer_size_;
diff --git a/net/filter/sdch_filter.h b/net/filter/sdch_filter.h
index 3cea340..861a9ae 100644
--- a/net/filter/sdch_filter.h
+++ b/net/filter/sdch_filter.h
@@ -41,7 +41,7 @@
   // destination buffer. Upon exit, *dest_len is the actual number of chars
   // written into the destination buffer.
   virtual FilterStatus ReadFilteredData(char* dest_buffer,
-                                        int* dest_len) OVERRIDE;
+                                        int* dest_len) override;
 
  private:
   // Internal status.  Once we enter an error state, we stop processing data.
diff --git a/net/ftp/ftp_network_layer.h b/net/ftp/ftp_network_layer.h
index 6040d02..6242f74 100644
--- a/net/ftp/ftp_network_layer.h
+++ b/net/ftp/ftp_network_layer.h
@@ -24,8 +24,8 @@
   static FtpTransactionFactory* CreateFactory(HostResolver* host_resolver);
 
   // FtpTransactionFactory methods:
-  virtual FtpTransaction* CreateTransaction() OVERRIDE;
-  virtual void Suspend(bool suspend) OVERRIDE;
+  virtual FtpTransaction* CreateTransaction() override;
+  virtual void Suspend(bool suspend) override;
 
  private:
   scoped_refptr<FtpNetworkSession> session_;
diff --git a/net/ftp/ftp_network_transaction.h b/net/ftp/ftp_network_transaction.h
index 5eb6aae..ee0f28a 100644
--- a/net/ftp/ftp_network_transaction.h
+++ b/net/ftp/ftp_network_transaction.h
@@ -38,14 +38,14 @@
   // FtpTransaction methods:
   virtual int Start(const FtpRequestInfo* request_info,
                     const CompletionCallback& callback,
-                    const BoundNetLog& net_log) OVERRIDE;
+                    const BoundNetLog& net_log) override;
   virtual int RestartWithAuth(const AuthCredentials& credentials,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
-  virtual const FtpResponseInfo* GetResponseInfo() const OVERRIDE;
-  virtual LoadState GetLoadState() const OVERRIDE;
-  virtual uint64 GetUploadProgress() const OVERRIDE;
+                   const CompletionCallback& callback) override;
+  virtual const FtpResponseInfo* GetResponseInfo() const override;
+  virtual LoadState GetLoadState() const override;
+  virtual uint64 GetUploadProgress() const override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(FtpNetworkTransactionTest,
diff --git a/net/ftp/ftp_network_transaction_unittest.cc b/net/ftp/ftp_network_transaction_unittest.cc
index c058d38..de407d5 100644
--- a/net/ftp/ftp_network_transaction_unittest.cc
+++ b/net/ftp/ftp_network_transaction_unittest.cc
@@ -63,7 +63,7 @@
     Init();
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -131,7 +131,7 @@
     return state_;
   }
 
-  virtual void Reset() OVERRIDE {
+  virtual void Reset() override {
     DynamicSocketDataProvider::Reset();
     Init();
   }
@@ -205,7 +205,7 @@
   FtpSocketDataProviderDirectoryListing() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -232,7 +232,7 @@
   FtpSocketDataProviderDirectoryListingWithPasvFallback() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -258,7 +258,7 @@
   FtpSocketDataProviderDirectoryListingZeroSize() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -278,7 +278,7 @@
   FtpSocketDataProviderVMSDirectoryListing() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -312,7 +312,7 @@
   FtpSocketDataProviderVMSDirectoryListingRootDirectory() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -348,7 +348,7 @@
   FtpSocketDataProviderFileDownloadWithFileTypecode() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -371,7 +371,7 @@
   FtpSocketDataProviderFileDownload() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -398,7 +398,7 @@
   FtpSocketDataProviderFileNotFound() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -428,7 +428,7 @@
   FtpSocketDataProviderFileDownloadWithPasvFallback() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -453,7 +453,7 @@
   FtpSocketDataProviderFileDownloadZeroSize() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -479,7 +479,7 @@
   FtpSocketDataProviderFileDownloadCWD451() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -501,7 +501,7 @@
   FtpSocketDataProviderVMSFileDownload() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -536,7 +536,7 @@
   FtpSocketDataProviderEscaping() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -565,7 +565,7 @@
   FtpSocketDataProviderFileDownloadTransferStarting() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -589,7 +589,7 @@
   FtpSocketDataProviderDirectoryListingTransferStarting() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -614,7 +614,7 @@
   FtpSocketDataProviderFileDownloadInvalidResponse() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -648,7 +648,7 @@
         epsv_response_length_(epsv_response_length),
         expected_state_(expected_state) {}
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -676,7 +676,7 @@
         expected_state_(expected_state) {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -701,7 +701,7 @@
         expected_state_(expected_state) {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -728,7 +728,7 @@
         expected_password_(expected_password) {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
@@ -755,7 +755,7 @@
   FtpSocketDataProviderCloseConnection() {
   }
 
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
+  virtual MockWriteResult OnWrite(const std::string& data) override {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
diff --git a/net/http/disk_cache_based_quic_server_info.h b/net/http/disk_cache_based_quic_server_info.h
index b0bb15c..7707037 100644
--- a/net/http/disk_cache_based_quic_server_info.h
+++ b/net/http/disk_cache_based_quic_server_info.h
@@ -31,11 +31,11 @@
                                HttpCache* http_cache);
 
   // QuicServerInfo implementation.
-  virtual void Start() OVERRIDE;
-  virtual int WaitForDataReady(const CompletionCallback& callback) OVERRIDE;
-  virtual bool IsDataReady() OVERRIDE;
-  virtual bool IsReadyToPersist() OVERRIDE;
-  virtual void Persist() OVERRIDE;
+  virtual void Start() override;
+  virtual int WaitForDataReady(const CompletionCallback& callback) override;
+  virtual bool IsDataReady() override;
+  virtual bool IsReadyToPersist() override;
+  virtual void Persist() override;
 
  private:
   struct CacheOperationDataShim;
diff --git a/net/http/failing_http_transaction_factory.cc b/net/http/failing_http_transaction_factory.cc
index 23a184f..0b97aa2 100644
--- a/net/http/failing_http_transaction_factory.cc
+++ b/net/http/failing_http_transaction_factory.cc
@@ -34,38 +34,38 @@
   // HttpTransaction
   virtual int Start(const HttpRequestInfo* request_info,
                     const CompletionCallback& callback,
-                    const BoundNetLog& net_log) OVERRIDE;
+                    const BoundNetLog& net_log) override;
   virtual int RestartIgnoringLastError(
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
   virtual int RestartWithCertificate(
       X509Certificate* client_cert,
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
   virtual int RestartWithAuth(
       const AuthCredentials& credentials,
-      const CompletionCallback& callback) OVERRIDE;
-  virtual bool IsReadyToRestartForAuth() OVERRIDE;
+      const CompletionCallback& callback) override;
+  virtual bool IsReadyToRestartForAuth() override;
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
-  virtual void StopCaching() OVERRIDE;
+                   const CompletionCallback& callback) override;
+  virtual void StopCaching() override;
   virtual bool GetFullRequestHeaders(
-      HttpRequestHeaders* headers) const OVERRIDE;
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
-  virtual void DoneReading() OVERRIDE;
-  virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE;
-  virtual LoadState GetLoadState() const OVERRIDE;
-  virtual UploadProgress GetUploadProgress() const OVERRIDE;
+      HttpRequestHeaders* headers) const override;
+  virtual int64 GetTotalReceivedBytes() const override;
+  virtual void DoneReading() override;
+  virtual const HttpResponseInfo* GetResponseInfo() const override;
+  virtual LoadState GetLoadState() const override;
+  virtual UploadProgress GetUploadProgress() const override;
   virtual void SetQuicServerInfo(
-      net::QuicServerInfo* quic_server_info) OVERRIDE;
+      net::QuicServerInfo* quic_server_info) override;
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
+  virtual void SetPriority(RequestPriority priority) override;
   virtual void SetWebSocketHandshakeStreamCreateHelper(
-      WebSocketHandshakeStreamBase::CreateHelper* create_helper) OVERRIDE;
+      WebSocketHandshakeStreamBase::CreateHelper* create_helper) override;
   virtual void SetBeforeNetworkStartCallback(
-      const BeforeNetworkStartCallback& callback) OVERRIDE;
+      const BeforeNetworkStartCallback& callback) override;
   virtual void SetBeforeProxyHeadersSentCallback(
-      const BeforeProxyHeadersSentCallback& callback) OVERRIDE;
-  virtual int ResumeNetworkStart() OVERRIDE;
+      const BeforeProxyHeadersSentCallback& callback) override;
+  virtual int ResumeNetworkStart() override;
 
  private:
   Error error_;
diff --git a/net/http/failing_http_transaction_factory.h b/net/http/failing_http_transaction_factory.h
index 84d87a7..8a785f5 100644
--- a/net/http/failing_http_transaction_factory.h
+++ b/net/http/failing_http_transaction_factory.h
@@ -28,9 +28,9 @@
   // HttpTransactionFactory:
   virtual int CreateTransaction(
       RequestPriority priority,
-      scoped_ptr<HttpTransaction>* trans) OVERRIDE;
-  virtual HttpCache* GetCache() OVERRIDE;
-  virtual HttpNetworkSession* GetSession() OVERRIDE;
+      scoped_ptr<HttpTransaction>* trans) override;
+  virtual HttpCache* GetCache() override;
+  virtual HttpNetworkSession* GetSession() override;
 
  private:
   HttpNetworkSession* session_;
diff --git a/net/http/http_auth_cache_unittest.cc b/net/http/http_auth_cache_unittest.cc
index e925c71..4002bab 100644
--- a/net/http/http_auth_cache_unittest.cc
+++ b/net/http/http_auth_cache_unittest.cc
@@ -33,19 +33,19 @@
   }
 
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuthChallengeTokenizer* challenge) OVERRIDE {
+      HttpAuthChallengeTokenizer* challenge) override {
     return HttpAuth::AUTHORIZATION_RESULT_REJECT;
   }
 
  protected:
-  virtual bool Init(HttpAuthChallengeTokenizer* challenge) OVERRIDE {
+  virtual bool Init(HttpAuthChallengeTokenizer* challenge) override {
     return false;  // Unused.
   }
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials*,
                                     const HttpRequestInfo*,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) OVERRIDE {
+                                    std::string* auth_token) override {
     *auth_token = "mock-credentials";
     return OK;
   }
diff --git a/net/http/http_auth_controller_unittest.cc b/net/http/http_auth_controller_unittest.cc
index 1a59b8d..306cabd 100644
--- a/net/http/http_auth_controller_unittest.cc
+++ b/net/http/http_auth_controller_unittest.cc
@@ -128,7 +128,7 @@
     }
 
    protected:
-    virtual bool Init(HttpAuthChallengeTokenizer* challenge) OVERRIDE {
+    virtual bool Init(HttpAuthChallengeTokenizer* challenge) override {
       HttpAuthHandlerMock::Init(challenge);
       set_allows_default_credentials(true);
       set_allows_explicit_credentials(false);
@@ -146,7 +146,7 @@
     virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                       const HttpRequestInfo* request,
                                       const CompletionCallback& callback,
-                                      std::string* auth_token) OVERRIDE {
+                                      std::string* auth_token) override {
       int result =
           HttpAuthHandlerMock::GenerateAuthTokenImpl(credentials,
                                                      request, callback,
diff --git a/net/http/http_auth_filter.h b/net/http/http_auth_filter.h
index 9f09ac1..419b8af 100644
--- a/net/http/http_auth_filter.h
+++ b/net/http/http_auth_filter.h
@@ -46,7 +46,7 @@
   const ProxyBypassRules& rules() const { return rules_; }
 
   // HttpAuthFilter methods:
-  virtual bool IsValid(const GURL& url, HttpAuth::Target target) const OVERRIDE;
+  virtual bool IsValid(const GURL& url, HttpAuth::Target target) const override;
 
  private:
   // Installs the whitelist.
diff --git a/net/http/http_auth_gssapi_posix.h b/net/http/http_auth_gssapi_posix.h
index 2e7b99b..41a1805 100644
--- a/net/http/http_auth_gssapi_posix.h
+++ b/net/http/http_auth_gssapi_posix.h
@@ -112,30 +112,30 @@
   virtual ~GSSAPISharedLibrary();
 
   // GSSAPILibrary methods:
-  virtual bool Init() OVERRIDE;
+  virtual bool Init() override;
   virtual OM_uint32 import_name(
       OM_uint32* minor_status,
       const gss_buffer_t input_name_buffer,
       const gss_OID input_name_type,
-      gss_name_t* output_name) OVERRIDE;
+      gss_name_t* output_name) override;
   virtual OM_uint32 release_name(
       OM_uint32* minor_status,
-      gss_name_t* input_name) OVERRIDE;
+      gss_name_t* input_name) override;
   virtual OM_uint32 release_buffer(
       OM_uint32* minor_status,
-      gss_buffer_t buffer) OVERRIDE;
+      gss_buffer_t buffer) override;
   virtual OM_uint32 display_name(
       OM_uint32* minor_status,
       const gss_name_t input_name,
       gss_buffer_t output_name_buffer,
-      gss_OID* output_name_type) OVERRIDE;
+      gss_OID* output_name_type) override;
   virtual OM_uint32 display_status(
       OM_uint32* minor_status,
       OM_uint32 status_value,
       int status_type,
       const gss_OID mech_type,
       OM_uint32* message_contex,
-      gss_buffer_t status_string) OVERRIDE;
+      gss_buffer_t status_string) override;
   virtual OM_uint32 init_sec_context(
       OM_uint32* minor_status,
       const gss_cred_id_t initiator_cred_handle,
@@ -149,18 +149,18 @@
       gss_OID* actual_mech_type,
       gss_buffer_t output_token,
       OM_uint32* ret_flags,
-      OM_uint32* time_rec) OVERRIDE;
+      OM_uint32* time_rec) override;
   virtual OM_uint32 wrap_size_limit(
       OM_uint32* minor_status,
       const gss_ctx_id_t context_handle,
       int conf_req_flag,
       gss_qop_t qop_req,
       OM_uint32 req_output_size,
-      OM_uint32* max_input_size) OVERRIDE;
+      OM_uint32* max_input_size) override;
   virtual OM_uint32 delete_sec_context(
       OM_uint32* minor_status,
       gss_ctx_id_t* context_handle,
-      gss_buffer_t output_token) OVERRIDE;
+      gss_buffer_t output_token) override;
   virtual OM_uint32 inquire_context(
       OM_uint32* minor_status,
       const gss_ctx_id_t context_handle,
@@ -170,7 +170,7 @@
       gss_OID* mech_type,
       OM_uint32* ctx_flags,
       int* locally_initiated,
-      int* open) OVERRIDE;
+      int* open) override;
 
  private:
   typedef typeof(&gss_import_name) gss_import_name_type;
diff --git a/net/http/http_auth_handler_basic.h b/net/http/http_auth_handler_basic.h
index 5d786f9..f718786 100644
--- a/net/http/http_auth_handler_basic.h
+++ b/net/http/http_auth_handler_basic.h
@@ -28,19 +28,19 @@
         CreateReason reason,
         int digest_nonce_count,
         const BoundNetLog& net_log,
-        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
+        scoped_ptr<HttpAuthHandler>* handler) override;
   };
 
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuthChallengeTokenizer* challenge) OVERRIDE;
+      HttpAuthChallengeTokenizer* challenge) override;
 
  protected:
-  virtual bool Init(HttpAuthChallengeTokenizer* challenge) OVERRIDE;
+  virtual bool Init(HttpAuthChallengeTokenizer* challenge) override;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) OVERRIDE;
+                                    std::string* auth_token) override;
 
  private:
   virtual ~HttpAuthHandlerBasic() {}
diff --git a/net/http/http_auth_handler_digest.h b/net/http/http_auth_handler_digest.h
index 6a960d9..ca148fe 100644
--- a/net/http/http_auth_handler_digest.h
+++ b/net/http/http_auth_handler_digest.h
@@ -38,7 +38,7 @@
   class DynamicNonceGenerator : public NonceGenerator {
    public:
     DynamicNonceGenerator();
-    virtual std::string GenerateNonce() const OVERRIDE;
+    virtual std::string GenerateNonce() const override;
    private:
     DISALLOW_COPY_AND_ASSIGN(DynamicNonceGenerator);
   };
@@ -49,7 +49,7 @@
    public:
     explicit FixedNonceGenerator(const std::string& nonce);
 
-    virtual std::string GenerateNonce() const OVERRIDE;
+    virtual std::string GenerateNonce() const override;
 
    private:
     const std::string nonce_;
@@ -71,22 +71,22 @@
         CreateReason reason,
         int digest_nonce_count,
         const BoundNetLog& net_log,
-        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
+        scoped_ptr<HttpAuthHandler>* handler) override;
 
    private:
     scoped_ptr<const NonceGenerator> nonce_generator_;
   };
 
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuthChallengeTokenizer* challenge) OVERRIDE;
+      HttpAuthChallengeTokenizer* challenge) override;
 
  protected:
-  virtual bool Init(HttpAuthChallengeTokenizer* challenge) OVERRIDE;
+  virtual bool Init(HttpAuthChallengeTokenizer* challenge) override;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) OVERRIDE;
+                                    std::string* auth_token) override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpAuthHandlerDigestTest, ParseChallenge);
diff --git a/net/http/http_auth_handler_factory.h b/net/http/http_auth_handler_factory.h
index e712aaf..efb432a 100644
--- a/net/http/http_auth_handler_factory.h
+++ b/net/http/http_auth_handler_factory.h
@@ -189,7 +189,7 @@
                                 CreateReason reason,
                                 int digest_nonce_count,
                                 const BoundNetLog& net_log,
-                                scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
+                                scoped_ptr<HttpAuthHandler>* handler) override;
 
  private:
   typedef std::map<std::string, HttpAuthHandlerFactory*> FactoryMap;
diff --git a/net/http/http_auth_handler_factory_unittest.cc b/net/http/http_auth_handler_factory_unittest.cc
index 06e8933..9860623 100644
--- a/net/http/http_auth_handler_factory_unittest.cc
+++ b/net/http/http_auth_handler_factory_unittest.cc
@@ -27,7 +27,7 @@
                                 CreateReason reason,
                                 int nonce_count,
                                 const BoundNetLog& net_log,
-                                scoped_ptr<HttpAuthHandler>* handler) OVERRIDE {
+                                scoped_ptr<HttpAuthHandler>* handler) override {
     handler->reset();
     return return_code_;
   }
diff --git a/net/http/http_auth_handler_mock.h b/net/http/http_auth_handler_mock.h
index fd9885b..b903e8c 100644
--- a/net/http/http_auth_handler_mock.h
+++ b/net/http/http_auth_handler_mock.h
@@ -49,7 +49,7 @@
         CreateReason reason,
         int nonce_count,
         const BoundNetLog& net_log,
-        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
+        scoped_ptr<HttpAuthHandler>* handler) override;
 
    private:
     ScopedVector<HttpAuthHandler> handlers_[HttpAuth::AUTH_NUM_TARGETS];
@@ -88,18 +88,18 @@
 
   // HttpAuthHandler:
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuthChallengeTokenizer* challenge) OVERRIDE;
-  virtual bool NeedsIdentity() OVERRIDE;
-  virtual bool AllowsDefaultCredentials() OVERRIDE;
-  virtual bool AllowsExplicitCredentials() OVERRIDE;
+      HttpAuthChallengeTokenizer* challenge) override;
+  virtual bool NeedsIdentity() override;
+  virtual bool AllowsDefaultCredentials() override;
+  virtual bool AllowsExplicitCredentials() override;
 
  protected:
-  virtual bool Init(HttpAuthChallengeTokenizer* challenge) OVERRIDE;
+  virtual bool Init(HttpAuthChallengeTokenizer* challenge) override;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) OVERRIDE;
+                                    std::string* auth_token) override;
 
  private:
   void OnResolveCanonicalName();
diff --git a/net/http/http_auth_handler_negotiate.h b/net/http/http_auth_handler_negotiate.h
index 90bd16c..8ff9244 100644
--- a/net/http/http_auth_handler_negotiate.h
+++ b/net/http/http_auth_handler_negotiate.h
@@ -76,7 +76,7 @@
         CreateReason reason,
         int digest_nonce_count,
         const BoundNetLog& net_log,
-        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
+        scoped_ptr<HttpAuthHandler>* handler) override;
 
    private:
     bool disable_cname_lookup_;
@@ -107,18 +107,18 @@
 
   // HttpAuthHandler:
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuthChallengeTokenizer* challenge) OVERRIDE;
-  virtual bool NeedsIdentity() OVERRIDE;
-  virtual bool AllowsDefaultCredentials() OVERRIDE;
-  virtual bool AllowsExplicitCredentials() OVERRIDE;
+      HttpAuthChallengeTokenizer* challenge) override;
+  virtual bool NeedsIdentity() override;
+  virtual bool AllowsDefaultCredentials() override;
+  virtual bool AllowsExplicitCredentials() override;
 
  protected:
-  virtual bool Init(HttpAuthChallengeTokenizer* challenge) OVERRIDE;
+  virtual bool Init(HttpAuthChallengeTokenizer* challenge) override;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) OVERRIDE;
+                                    std::string* auth_token) override;
 
  private:
   enum State {
diff --git a/net/http/http_auth_handler_ntlm.h b/net/http/http_auth_handler_ntlm.h
index 9e2abc6..5a998ac 100644
--- a/net/http/http_auth_handler_ntlm.h
+++ b/net/http/http_auth_handler_ntlm.h
@@ -48,7 +48,7 @@
         CreateReason reason,
         int digest_nonce_count,
         const BoundNetLog& net_log,
-        scoped_ptr<HttpAuthHandler>* handler) OVERRIDE;
+        scoped_ptr<HttpAuthHandler>* handler) override;
 #if defined(NTLM_SSPI)
     // Set the SSPILibrary to use. Typically the only callers which need to use
     // this are unit tests which pass in a mocked-out version of the SSPI
@@ -104,24 +104,24 @@
                       URLSecurityManager* url_security_manager);
 #endif
 
-  virtual bool NeedsIdentity() OVERRIDE;
+  virtual bool NeedsIdentity() override;
 
-  virtual bool AllowsDefaultCredentials() OVERRIDE;
+  virtual bool AllowsDefaultCredentials() override;
 
   virtual HttpAuth::AuthorizationResult HandleAnotherChallenge(
-      HttpAuthChallengeTokenizer* challenge) OVERRIDE;
+      HttpAuthChallengeTokenizer* challenge) override;
 
  protected:
   // This function acquires a credentials handle in the SSPI implementation.
   // It does nothing in the portable implementation.
   int InitializeBeforeFirstChallenge();
 
-  virtual bool Init(HttpAuthChallengeTokenizer* tok) OVERRIDE;
+  virtual bool Init(HttpAuthChallengeTokenizer* tok) override;
 
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) OVERRIDE;
+                                    std::string* auth_token) override;
 
  private:
   virtual ~HttpAuthHandlerNTLM();
diff --git a/net/http/http_basic_stream.h b/net/http/http_basic_stream.h
index 00253c3..541994d 100644
--- a/net/http/http_basic_stream.h
+++ b/net/http/http_basic_stream.h
@@ -36,49 +36,49 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
 
   virtual int SendRequest(const HttpRequestHeaders& headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
 
-  virtual UploadProgress GetUploadProgress() const OVERRIDE;
+  virtual UploadProgress GetUploadProgress() const override;
 
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE;
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override;
 
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
 
-  virtual void Close(bool not_reusable) OVERRIDE;
+  virtual void Close(bool not_reusable) override;
 
-  virtual HttpStream* RenewStreamForAuth() OVERRIDE;
+  virtual HttpStream* RenewStreamForAuth() override;
 
-  virtual bool IsResponseBodyComplete() const OVERRIDE;
+  virtual bool IsResponseBodyComplete() const override;
 
-  virtual bool CanFindEndOfResponse() const OVERRIDE;
+  virtual bool CanFindEndOfResponse() const override;
 
-  virtual bool IsConnectionReused() const OVERRIDE;
+  virtual bool IsConnectionReused() const override;
 
-  virtual void SetConnectionReused() OVERRIDE;
+  virtual void SetConnectionReused() override;
 
-  virtual bool IsConnectionReusable() const OVERRIDE;
+  virtual bool IsConnectionReusable() const override;
 
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+  virtual int64 GetTotalReceivedBytes() const override;
 
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
 
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override;
 
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
 
-  virtual bool IsSpdyHttpStream() const OVERRIDE;
+  virtual bool IsSpdyHttpStream() const override;
 
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE;
+  virtual void Drain(HttpNetworkSession* session) override;
 
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+  virtual void SetPriority(RequestPriority priority) override;
 
  private:
   HttpStreamParser* parser() const { return state_.parser(); }
diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index cbf2615..1c8e62a 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -23,6 +23,7 @@
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -286,7 +287,7 @@
   }
 
   virtual QuicServerInfo* GetForServer(
-      const QuicServerId& server_id) OVERRIDE {
+      const QuicServerId& server_id) override {
     return new DiskCacheBasedQuicServerInfo(server_id, http_cache_);
   }
 
@@ -1355,6 +1356,11 @@
 void HttpCache::OnPendingOpComplete(const base::WeakPtr<HttpCache>& cache,
                                     PendingOp* pending_op,
                                     int rv) {
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/422516 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "422516 HttpCache::OnPendingOpComplete"));
+
   if (cache.get()) {
     cache->OnIOComplete(rv, pending_op);
   } else {
diff --git a/net/http/http_cache.h b/net/http/http_cache.h
index 3f59839..5e6851f 100644
--- a/net/http/http_cache.h
+++ b/net/http/http_cache.h
@@ -116,7 +116,7 @@
     // BackendFactory implementation.
     virtual int CreateBackend(NetLog* net_log,
                               scoped_ptr<disk_cache::Backend>* backend,
-                              const CompletionCallback& callback) OVERRIDE;
+                              const CompletionCallback& callback) override;
 
    private:
     CacheType type_;
@@ -214,9 +214,9 @@
 
   // HttpTransactionFactory implementation:
   virtual int CreateTransaction(RequestPriority priority,
-                                scoped_ptr<HttpTransaction>* trans) OVERRIDE;
-  virtual HttpCache* GetCache() OVERRIDE;
-  virtual HttpNetworkSession* GetSession() OVERRIDE;
+                                scoped_ptr<HttpTransaction>* trans) override;
+  virtual HttpCache* GetCache() override;
+  virtual HttpNetworkSession* GetSession() override;
 
   base::WeakPtr<HttpCache> GetWeakPtr() { return weak_factory_.GetWeakPtr(); }
 
diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc
index 5e90131..ddd0481 100644
--- a/net/http/http_cache_transaction.cc
+++ b/net/http/http_cache_transaction.cc
@@ -21,6 +21,7 @@
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
@@ -2944,6 +2945,10 @@
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/422516 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("422516 Transaction::OnIOComplete"));
+
   DoLoop(result);
 }
 
diff --git a/net/http/http_cache_transaction.h b/net/http/http_cache_transaction.h
index b63e859..cc1f467 100644
--- a/net/http/http_cache_transaction.h
+++ b/net/http/http_cache_transaction.h
@@ -112,37 +112,37 @@
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo* request_info,
                     const CompletionCallback& callback,
-                    const BoundNetLog& net_log) OVERRIDE;
+                    const BoundNetLog& net_log) override;
   virtual int RestartIgnoringLastError(
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
   virtual int RestartWithCertificate(
       X509Certificate* client_cert,
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
   virtual int RestartWithAuth(const AuthCredentials& credentials,
-                              const CompletionCallback& callback) OVERRIDE;
-  virtual bool IsReadyToRestartForAuth() OVERRIDE;
+                              const CompletionCallback& callback) override;
+  virtual bool IsReadyToRestartForAuth() override;
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
-  virtual void StopCaching() OVERRIDE;
+                   const CompletionCallback& callback) override;
+  virtual void StopCaching() override;
   virtual bool GetFullRequestHeaders(
-      HttpRequestHeaders* headers) const OVERRIDE;
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
-  virtual void DoneReading() OVERRIDE;
-  virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE;
-  virtual LoadState GetLoadState() const OVERRIDE;
-  virtual UploadProgress GetUploadProgress(void) const OVERRIDE;
-  virtual void SetQuicServerInfo(QuicServerInfo* quic_server_info) OVERRIDE;
+      HttpRequestHeaders* headers) const override;
+  virtual int64 GetTotalReceivedBytes() const override;
+  virtual void DoneReading() override;
+  virtual const HttpResponseInfo* GetResponseInfo() const override;
+  virtual LoadState GetLoadState() const override;
+  virtual UploadProgress GetUploadProgress(void) const override;
+  virtual void SetQuicServerInfo(QuicServerInfo* quic_server_info) override;
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
+  virtual void SetPriority(RequestPriority priority) override;
   virtual void SetWebSocketHandshakeStreamCreateHelper(
-      net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) OVERRIDE;
+      net::WebSocketHandshakeStreamBase::CreateHelper* create_helper) override;
   virtual void SetBeforeNetworkStartCallback(
-      const BeforeNetworkStartCallback& callback) OVERRIDE;
+      const BeforeNetworkStartCallback& callback) override;
   virtual void SetBeforeProxyHeadersSentCallback(
-      const BeforeProxyHeadersSentCallback& callback) OVERRIDE;
-  virtual int ResumeNetworkStart() OVERRIDE;
+      const BeforeProxyHeadersSentCallback& callback) override;
+  virtual int ResumeNetworkStart() override;
 
  private:
   static const size_t kNumValidationHeaders = 2;
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index a7a04f1..0b05057 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -14,6 +14,7 @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/cache_type.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
@@ -21,7 +22,6 @@
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_data_stream.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_byte_range.h"
@@ -498,12 +498,12 @@
  public:
   virtual ~FakeWebSocketHandshakeStreamCreateHelper() {}
   virtual net::WebSocketHandshakeStreamBase* CreateBasicStream(
-      scoped_ptr<net::ClientSocketHandle> connect, bool using_proxy) OVERRIDE {
+      scoped_ptr<net::ClientSocketHandle> connect, bool using_proxy) override {
     return NULL;
   }
   virtual net::WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<net::SpdySession>& session,
-      bool use_relative_url) OVERRIDE {
+      bool use_relative_url) override {
     return NULL;
   }
 };
@@ -2774,7 +2774,8 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), kUploadId);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(),
+                                                   kUploadId);
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
@@ -2805,7 +2806,8 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), kUploadId);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(),
+                                                   kUploadId);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
@@ -2824,7 +2826,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 1);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 1);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   MockHttpRequest req1(transaction);
@@ -2863,7 +2865,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 1);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 1);
 
   transaction.method = "POST";
   transaction.status = "HTTP/1.1 205 No Content";
@@ -2902,7 +2904,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   transaction.method = "POST";
   transaction.status = "HTTP/1.1 205 No Content";
@@ -2933,7 +2935,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   MockTransaction transaction(kSimplePOST_Transaction);
   AddMockTransaction(&transaction);
@@ -2962,7 +2964,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 1);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 1);
 
   transaction.method = "POST";
   transaction.status = "HTTP/1.1 100 Continue";
@@ -3273,7 +3275,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
@@ -3302,7 +3304,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   transaction.method = "PUT";
   MockHttpRequest req2(transaction);
@@ -3338,7 +3340,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   transaction.method = "PUT";
   transaction.status = "HTTP/1.1 305 Use Proxy";
@@ -3376,7 +3378,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   transaction.method = "PUT";
   transaction.status = "HTTP/1.1 404 Not Found";
@@ -3406,7 +3408,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
@@ -3435,7 +3437,7 @@
 
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader("hello", 5));
-  net::UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  net::ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   transaction.method = "DELETE";
   MockHttpRequest req2(transaction);
@@ -7290,3 +7292,46 @@
 
   RemoveMockTransaction(&transaction);
 }
+
+// Makes sure that a request stops using the cache when the response headers
+// with "Cache-Control: no-store" arrives. That means that another request for
+// the same URL can be processed before the response body of the original
+// request arrives.
+TEST(HttpCache, NoStoreResponseShouldNotBlockFollowingRequests) {
+  MockHttpCache cache;
+  ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
+  mock_transaction.response_headers = "Cache-Control: no-store\n";
+  MockHttpRequest request(mock_transaction);
+
+  scoped_ptr<Context> first(new Context);
+  first->result = cache.CreateTransaction(&first->trans);
+  ASSERT_EQ(net::OK, first->result);
+  EXPECT_EQ(net::LOAD_STATE_IDLE, first->trans->GetLoadState());
+  first->result = first->trans->Start(
+      &request, first->callback.callback(), net::BoundNetLog());
+  EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_CACHE, first->trans->GetLoadState());
+
+  base::MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(net::LOAD_STATE_IDLE, first->trans->GetLoadState());
+  ASSERT_TRUE(first->trans->GetResponseInfo());
+  EXPECT_TRUE(first->trans->GetResponseInfo()->headers->HasHeaderValue(
+      "Cache-Control", "no-store"));
+  // Here we have read the response header but not read the response body yet.
+
+  // Let us create the second (read) transaction.
+  scoped_ptr<Context> second(new Context);
+  second->result = cache.CreateTransaction(&second->trans);
+  ASSERT_EQ(net::OK, second->result);
+  EXPECT_EQ(net::LOAD_STATE_IDLE, second->trans->GetLoadState());
+  second->result = second->trans->Start(
+      &request, second->callback.callback(), net::BoundNetLog());
+
+  // Here the second transaction proceeds without reading the first body.
+  EXPECT_EQ(net::LOAD_STATE_WAITING_FOR_CACHE, second->trans->GetLoadState());
+  base::MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(net::LOAD_STATE_IDLE, second->trans->GetLoadState());
+  ASSERT_TRUE(second->trans->GetResponseInfo());
+  EXPECT_TRUE(second->trans->GetResponseInfo()->headers->HasHeaderValue(
+      "Cache-Control", "no-store"));
+  ReadAndVerifyTransaction(second->trans.get(), kSimpleGET_Transaction);
+}
diff --git a/net/http/http_network_layer.h b/net/http/http_network_layer.h
index fc94d0a..58b02f2 100644
--- a/net/http/http_network_layer.h
+++ b/net/http/http_network_layer.h
@@ -44,13 +44,13 @@
 
   // HttpTransactionFactory methods:
   virtual int CreateTransaction(RequestPriority priority,
-                                scoped_ptr<HttpTransaction>* trans) OVERRIDE;
-  virtual HttpCache* GetCache() OVERRIDE;
-  virtual HttpNetworkSession* GetSession() OVERRIDE;
+                                scoped_ptr<HttpTransaction>* trans) override;
+  virtual HttpCache* GetCache() override;
+  virtual HttpNetworkSession* GetSession() override;
 
   // base::PowerObserver methods:
-  virtual void OnSuspend() OVERRIDE;
-  virtual void OnResume() OVERRIDE;
+  virtual void OnSuspend() override;
+  virtual void OnResume() override;
 
  private:
   const scoped_refptr<HttpNetworkSession> session_;
diff --git a/net/http/http_network_transaction.h b/net/http/http_network_transaction.h
index 895ecc3..57ebdf7 100644
--- a/net/http/http_network_transaction.h
+++ b/net/http/http_network_transaction.h
@@ -47,63 +47,63 @@
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo* request_info,
                     const CompletionCallback& callback,
-                    const BoundNetLog& net_log) OVERRIDE;
+                    const BoundNetLog& net_log) override;
   virtual int RestartIgnoringLastError(
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
   virtual int RestartWithCertificate(
       X509Certificate* client_cert,
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
   virtual int RestartWithAuth(const AuthCredentials& credentials,
-                              const CompletionCallback& callback) OVERRIDE;
-  virtual bool IsReadyToRestartForAuth() OVERRIDE;
+                              const CompletionCallback& callback) override;
+  virtual bool IsReadyToRestartForAuth() override;
 
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
-  virtual void StopCaching() OVERRIDE;
+                   const CompletionCallback& callback) override;
+  virtual void StopCaching() override;
   virtual bool GetFullRequestHeaders(
-      HttpRequestHeaders* headers) const OVERRIDE;
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
-  virtual void DoneReading() OVERRIDE;
-  virtual const HttpResponseInfo* GetResponseInfo() const OVERRIDE;
-  virtual LoadState GetLoadState() const OVERRIDE;
-  virtual UploadProgress GetUploadProgress() const OVERRIDE;
-  virtual void SetQuicServerInfo(QuicServerInfo* quic_server_info) OVERRIDE;
+      HttpRequestHeaders* headers) const override;
+  virtual int64 GetTotalReceivedBytes() const override;
+  virtual void DoneReading() override;
+  virtual const HttpResponseInfo* GetResponseInfo() const override;
+  virtual LoadState GetLoadState() const override;
+  virtual UploadProgress GetUploadProgress() const override;
+  virtual void SetQuicServerInfo(QuicServerInfo* quic_server_info) override;
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
+  virtual void SetPriority(RequestPriority priority) override;
   virtual void SetWebSocketHandshakeStreamCreateHelper(
-      WebSocketHandshakeStreamBase::CreateHelper* create_helper) OVERRIDE;
+      WebSocketHandshakeStreamBase::CreateHelper* create_helper) override;
   virtual void SetBeforeNetworkStartCallback(
-      const BeforeNetworkStartCallback& callback) OVERRIDE;
+      const BeforeNetworkStartCallback& callback) override;
   virtual void SetBeforeProxyHeadersSentCallback(
-      const BeforeProxyHeadersSentCallback& callback) OVERRIDE;
-  virtual int ResumeNetworkStart() OVERRIDE;
+      const BeforeProxyHeadersSentCallback& callback) override;
+  virtual int ResumeNetworkStart() override;
 
   // HttpStreamRequest::Delegate methods:
   virtual void OnStreamReady(const SSLConfig& used_ssl_config,
                              const ProxyInfo& used_proxy_info,
-                             HttpStreamBase* stream) OVERRIDE;
+                             HttpStreamBase* stream) override;
   virtual void OnWebSocketHandshakeStreamReady(
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
-      WebSocketHandshakeStreamBase* stream) OVERRIDE;
+      WebSocketHandshakeStreamBase* stream) override;
   virtual void OnStreamFailed(int status,
-                              const SSLConfig& used_ssl_config) OVERRIDE;
+                              const SSLConfig& used_ssl_config) override;
   virtual void OnCertificateError(int status,
                                   const SSLConfig& used_ssl_config,
-                                  const SSLInfo& ssl_info) OVERRIDE;
+                                  const SSLInfo& ssl_info) override;
   virtual void OnNeedsProxyAuth(
       const HttpResponseInfo& response_info,
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
-      HttpAuthController* auth_controller) OVERRIDE;
+      HttpAuthController* auth_controller) override;
   virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
-                                 SSLCertRequestInfo* cert_info) OVERRIDE;
+                                 SSLCertRequestInfo* cert_info) override;
   virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
                                           const SSLConfig& used_ssl_config,
                                           const ProxyInfo& used_proxy_info,
-                                          HttpStreamBase* stream) OVERRIDE;
+                                          HttpStreamBase* stream) override;
 
  private:
   friend class HttpNetworkTransactionSSLTest;
diff --git a/net/http/http_network_transaction_ssl_unittest.cc b/net/http/http_network_transaction_ssl_unittest.cc
index ab7eadf..7b95f79 100644
--- a/net/http/http_network_transaction_ssl_unittest.cc
+++ b/net/http/http_network_transaction_ssl_unittest.cc
@@ -31,7 +31,7 @@
     ssl_config_.version_max = SSL_PROTOCOL_VERSION_TLS1;
   }
 
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {
+  virtual void GetSSLConfig(SSLConfig* config) override {
     *config = ssl_config_;
   }
 
@@ -48,7 +48,7 @@
     ssl_config_.version_max = SSL_PROTOCOL_VERSION_TLS1_1;
   }
 
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {
+  virtual void GetSSLConfig(SSLConfig* config) override {
     *config = ssl_config_;
   }
 
diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index ce61d6e..7531c91 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -22,7 +22,9 @@
 #include "base/test/test_file_util.h"
 #include "net/base/auth.h"
 #include "net/base/capturing_net_log.h"
+#include "net/base/chunked_upload_data_stream.h"
 #include "net/base/completion_callback.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
 #include "net/base/net_log.h"
@@ -31,7 +33,6 @@
 #include "net/base/test_completion_callback.h"
 #include "net/base/test_data_directory.h"
 #include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/cert/mock_cert_verifier.h"
 #include "net/dns/host_cache.h"
@@ -1111,7 +1112,7 @@
 TEST_P(HttpNetworkTransactionTest, Ignores100) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -5016,7 +5017,7 @@
 TEST_P(HttpNetworkTransactionTest, ResendRequestOnWriteBodyError) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request[2];
   // Transaction 1: a GET request that succeeds.  The socket is recycled
@@ -8102,7 +8103,7 @@
                                   0,
                                   kuint64max,
                                   base::Time()));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -8159,7 +8160,7 @@
                                   0,
                                   kuint64max,
                                   base::Time()));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -8198,15 +8199,15 @@
     const CompletionCallback& callback() const { return callback_; }
 
     // UploadElementReader overrides:
-    virtual int Init(const CompletionCallback& callback) OVERRIDE {
+    virtual int Init(const CompletionCallback& callback) override {
       callback_ = callback;
       return ERR_IO_PENDING;
     }
-    virtual uint64 GetContentLength() const OVERRIDE { return 0; }
-    virtual uint64 BytesRemaining() const OVERRIDE { return 0; }
+    virtual uint64 GetContentLength() const override { return 0; }
+    virtual uint64 BytesRemaining() const override { return 0; }
     virtual int Read(IOBuffer* buf,
                      int buf_length,
-                     const CompletionCallback& callback) OVERRIDE {
+                     const CompletionCallback& callback) override {
       return ERR_FAILED;
     }
 
@@ -8217,7 +8218,7 @@
   FakeUploadElementReader* fake_reader = new FakeUploadElementReader;
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(fake_reader);
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -9105,7 +9106,7 @@
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     ProxyServer proxy_server(ProxyServer::SCHEME_HTTP,
                              HostPortPair("myproxy", 80));
     results->UseProxyServer(proxy_server);
@@ -9113,21 +9114,21 @@
     return OK;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
+  virtual void CancelRequest(RequestHandle request) override {
     NOTREACHED();
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
+  virtual LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
+  virtual void CancelSetPacScript() override {
     NOTREACHED();
   }
 
   virtual int SetPacScript(const scoped_refptr<ProxyResolverScriptData>&,
-                           const CompletionCallback& /*callback*/) OVERRIDE {
+                           const CompletionCallback& /*callback*/) override {
     return OK;
   }
 
@@ -10069,7 +10070,7 @@
   virtual int GenerateAuthTokenImpl(const AuthCredentials* credentials,
                                     const HttpRequestInfo* request,
                                     const CompletionCallback& callback,
-                                    std::string* auth_token) OVERRIDE {
+                                    std::string* auth_token) override {
     *url_ = request->url;
     return HttpAuthHandlerMock::GenerateAuthTokenImpl(
         credentials, request, callback, auth_token);
@@ -11166,21 +11167,21 @@
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE {
+                      const BoundNetLog& net_log) override {
     return host_resolver_.Resolve(
         info, priority, addresses, callback, out_req, net_log);
   }
 
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE {
+                               const BoundNetLog& net_log) override {
     int rv = host_resolver_.ResolveFromCache(info, addresses, net_log);
     if (rv == OK && info.host_port_pair().Equals(host_port_))
       host_resolver_.GetHostCache()->clear();
     return rv;
   }
 
-  virtual void CancelRequest(RequestHandle req) OVERRIDE {
+  virtual void CancelRequest(RequestHandle req) override {
     host_resolver_.CancelRequest(req);
   }
 
@@ -12212,83 +12213,83 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE {
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
   virtual int ReadResponseBody(IOBuffer* buf, int buf_len,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual void Close(bool not_reusable) OVERRIDE {}
+  virtual void Close(bool not_reusable) override {}
 
-  virtual bool IsResponseBodyComplete() const OVERRIDE {
+  virtual bool IsResponseBodyComplete() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool CanFindEndOfResponse() const OVERRIDE {
+  virtual bool CanFindEndOfResponse() const override {
     return false;
   }
 
-  virtual bool IsConnectionReused() const OVERRIDE {
+  virtual bool IsConnectionReused() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void SetConnectionReused() OVERRIDE {
+  virtual void SetConnectionReused() override {
     ADD_FAILURE();
   }
 
-  virtual bool IsConnectionReusable() const OVERRIDE {
+  virtual bool IsConnectionReusable() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE {
+  virtual int64 GetTotalReceivedBytes() const override {
     ADD_FAILURE();
     return 0;
   }
 
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE {
+      LoadTimingInfo* load_timing_info) const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override {
     ADD_FAILURE();
   }
 
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE {
+      SSLCertRequestInfo* cert_request_info) override {
     ADD_FAILURE();
   }
 
-  virtual bool IsSpdyHttpStream() const OVERRIDE {
+  virtual bool IsSpdyHttpStream() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE {
+  virtual void Drain(HttpNetworkSession* session) override {
     ADD_FAILURE();
   }
 
-  virtual void SetPriority(RequestPriority priority) OVERRIDE {
+  virtual void SetPriority(RequestPriority priority) override {
     priority_ = priority;
   }
 
@@ -12337,29 +12338,29 @@
   }
 
   virtual int RestartTunnelWithProxyAuth(
-      const AuthCredentials& credentials) OVERRIDE {
+      const AuthCredentials& credentials) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual LoadState GetLoadState() const OVERRIDE {
+  virtual LoadState GetLoadState() const override {
     ADD_FAILURE();
     return LoadState();
   }
 
-  virtual void SetPriority(RequestPriority priority) OVERRIDE {
+  virtual void SetPriority(RequestPriority priority) override {
     priority_ = priority;
   }
 
-  virtual bool was_npn_negotiated() const OVERRIDE {
+  virtual bool was_npn_negotiated() const override {
     return false;
   }
 
-  virtual NextProto protocol_negotiated() const OVERRIDE {
+  virtual NextProto protocol_negotiated() const override {
     return kProtoUnknown;
   }
 
-  virtual bool using_spdy() const OVERRIDE {
+  virtual bool using_spdy() const override {
     return false;
   }
 
@@ -12389,7 +12390,7 @@
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
-      const BoundNetLog& net_log) OVERRIDE {
+      const BoundNetLog& net_log) override {
     FakeStreamRequest* fake_request = new FakeStreamRequest(priority, delegate);
     last_stream_request_ = fake_request->AsWeakPtr();
     return fake_request;
@@ -12402,7 +12403,7 @@
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       WebSocketHandshakeStreamBase::CreateHelper* create_helper,
-      const BoundNetLog& net_log) OVERRIDE {
+      const BoundNetLog& net_log) override {
     FakeStreamRequest* fake_request =
         new FakeStreamRequest(priority, delegate, create_helper);
     last_stream_request_ = fake_request->AsWeakPtr();
@@ -12413,11 +12414,11 @@
                                  const HttpRequestInfo& info,
                                  RequestPriority priority,
                                  const SSLConfig& server_ssl_config,
-                                 const SSLConfig& proxy_ssl_config) OVERRIDE {
+                                 const SSLConfig& proxy_ssl_config) override {
     ADD_FAILURE();
   }
 
-  virtual const HostMappingRules* GetHostMappingRules() const OVERRIDE {
+  virtual const HostMappingRules* GetHostMappingRules() const override {
     ADD_FAILURE();
     return NULL;
   }
@@ -12435,14 +12436,14 @@
  public:
   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
-      bool using_proxy) OVERRIDE {
+      bool using_proxy) override {
     NOTREACHED();
     return NULL;
   }
 
   virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<SpdySession>& session,
-      bool use_relative_url) OVERRIDE {
+      bool use_relative_url) override {
     NOTREACHED();
     return NULL;
   };
@@ -12731,7 +12732,7 @@
 TEST_P(HttpNetworkTransactionTest, PostReadsErrorResponseAfterReset) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -12838,7 +12839,7 @@
 
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request2;
   request2.method = "POST";
@@ -12870,7 +12871,7 @@
        PostReadsErrorResponseAfterResetPartialBodySent) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -12925,7 +12926,7 @@
 TEST_P(HttpNetworkTransactionTest, ChunkedPostReadsErrorResponseAfterReset) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0);
+  ChunkedUploadDataStream upload_data_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -12964,7 +12965,7 @@
   // the test more future proof.
   base::RunLoop().RunUntilIdle();
 
-  upload_data_stream.AppendChunk("last chunk", 10, true);
+  upload_data_stream.AppendData("last chunk", 10, true);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ -12984,7 +12985,7 @@
 TEST_P(HttpNetworkTransactionTest, PostReadsErrorResponseAfterResetAnd100) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -13037,7 +13038,7 @@
 TEST_P(HttpNetworkTransactionTest, PostIgnoresNonErrorResponseAfterReset) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -13082,7 +13083,7 @@
        PostIgnoresNonErrorResponseAfterResetAnd100) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -13128,7 +13129,7 @@
 TEST_P(HttpNetworkTransactionTest, PostIgnoresHttp09ResponseAfterReset) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -13171,7 +13172,7 @@
 TEST_P(HttpNetworkTransactionTest, PostIgnoresPartial400HeadersAfterReset) {
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(new UploadBytesElementReader("foo", 3));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
diff --git a/net/http/http_proxy_client_socket.h b/net/http/http_proxy_client_socket.h
index 6761621..87eeda4 100644
--- a/net/http/http_proxy_client_socket.h
+++ b/net/http/http_proxy_client_socket.h
@@ -55,39 +55,39 @@
   virtual ~HttpProxyClientSocket();
 
   // ProxyClientSocket implementation.
-  virtual const HttpResponseInfo* GetConnectResponseInfo() const OVERRIDE;
-  virtual HttpStream* CreateConnectResponseStream() OVERRIDE;
-  virtual int RestartWithAuth(const CompletionCallback& callback) OVERRIDE;
+  virtual const HttpResponseInfo* GetConnectResponseInfo() const override;
+  virtual HttpStream* CreateConnectResponseStream() override;
+  virtual int RestartWithAuth(const CompletionCallback& callback) override;
   virtual const scoped_refptr<HttpAuthController>& GetAuthController() const
-      OVERRIDE;
-  virtual bool IsUsingSpdy() const OVERRIDE;
-  virtual NextProto GetProtocolNegotiated() const OVERRIDE;
+      override;
+  virtual bool IsUsingSpdy() const override;
+  virtual NextProto GetProtocolNegotiated() const override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
 
  private:
   enum State {
diff --git a/net/http/http_proxy_client_socket_pool.h b/net/http/http_proxy_client_socket_pool.h
index 7ce0f37..9dac090 100644
--- a/net/http/http_proxy_client_socket_pool.h
+++ b/net/http/http_proxy_client_socket_pool.h
@@ -114,9 +114,9 @@
   virtual ~HttpProxyConnectJob();
 
   // ConnectJob methods.
-  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual LoadState GetLoadState() const override;
 
-  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) OVERRIDE;
+  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) override;
 
  private:
   enum State {
@@ -157,7 +157,7 @@
   // that the tunnel needs authentication credentials, the socket will be
   // returned in this case, and must be release back to the pool; or
   // a standard net error code will be returned.
-  virtual int ConnectInternal() OVERRIDE;
+  virtual int ConnectInternal() override;
 
   scoped_refptr<HttpProxySocketParams> params_;
   TransportClientSocketPool* const transport_pool_;
@@ -205,51 +205,51 @@
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
 
   virtual void RequestSockets(const std::string& group_name,
                               const void* params,
                               int num_sockets,
-                              const BoundNetLog& net_log) OVERRIDE;
+                              const BoundNetLog& net_log) override;
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
 
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
+                             int id) override;
 
-  virtual void FlushWithError(int error) OVERRIDE;
+  virtual void FlushWithError(int error) override;
 
-  virtual void CloseIdleSockets() OVERRIDE;
+  virtual void CloseIdleSockets() override;
 
-  virtual int IdleSocketCount() const OVERRIDE;
+  virtual int IdleSocketCount() const override;
 
   virtual int IdleSocketCountInGroup(
-      const std::string& group_name) const OVERRIDE;
+      const std::string& group_name) const override;
 
   virtual LoadState GetLoadState(
       const std::string& group_name,
-      const ClientSocketHandle* handle) const OVERRIDE;
+      const ClientSocketHandle* handle) const override;
 
   virtual base::DictionaryValue* GetInfoAsValue(
       const std::string& name,
       const std::string& type,
-      bool include_nested_pools) const OVERRIDE;
+      bool include_nested_pools) const override;
 
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
+  virtual base::TimeDelta ConnectionTimeout() const override;
 
-  virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
+  virtual ClientSocketPoolHistograms* histograms() const override;
 
   // LowerLayeredPool implementation.
-  virtual bool IsStalled() const OVERRIDE;
+  virtual bool IsStalled() const override;
 
-  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
+  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 
-  virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
+  virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 
   // HigherLayeredPool implementation.
-  virtual bool CloseOneIdleConnection() OVERRIDE;
+  virtual bool CloseOneIdleConnection() override;
 
  private:
   typedef ClientSocketPoolBase<HttpProxySocketParams> PoolBase;
@@ -267,9 +267,9 @@
     virtual scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const PoolBase::Request& request,
-        ConnectJob::Delegate* delegate) const OVERRIDE;
+        ConnectJob::Delegate* delegate) const override;
 
-    virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
+    virtual base::TimeDelta ConnectionTimeout() const override;
 
    private:
     TransportClientSocketPool* const transport_pool_;
diff --git a/net/http/http_proxy_client_socket_pool_unittest.cc b/net/http/http_proxy_client_socket_pool_unittest.cc
index c6433af..98b7322 100644
--- a/net/http/http_proxy_client_socket_pool_unittest.cc
+++ b/net/http/http_proxy_client_socket_pool_unittest.cc
@@ -66,7 +66,7 @@
         on_tunnel_headers_received_called_(false) {
   }
 
-  virtual ~TestProxyDelegate() OVERRIDE {
+  virtual ~TestProxyDelegate() override {
   }
 
   bool on_before_tunnel_request_called() const {
@@ -92,21 +92,21 @@
   virtual void OnResolveProxy(const GURL& url,
                               int load_flags,
                               const ProxyService& proxy_service,
-                              ProxyInfo* result) OVERRIDE {
+                              ProxyInfo* result) override {
   }
 
   virtual void OnFallback(const ProxyServer& bad_proxy,
-                          int net_error) OVERRIDE {
+                          int net_error) override {
   }
 
   virtual void OnBeforeSendHeaders(URLRequest* request,
                                    const ProxyInfo& proxy_info,
-                                   HttpRequestHeaders* headers) OVERRIDE {
+                                   HttpRequestHeaders* headers) override {
   }
 
   virtual void OnBeforeTunnelRequest(
       const net::HostPortPair& proxy_server,
-      net::HttpRequestHeaders* extra_headers) OVERRIDE {
+      net::HttpRequestHeaders* extra_headers) override {
     on_before_tunnel_request_called_ = true;
     if (extra_headers) {
       extra_headers->SetHeader("Foo", proxy_server.ToString());
@@ -116,7 +116,7 @@
   virtual void OnTunnelHeadersReceived(
       const net::HostPortPair& origin,
       const net::HostPortPair& proxy_server,
-      const net::HttpResponseHeaders& response_headers) OVERRIDE {
+      const net::HttpResponseHeaders& response_headers) override {
     on_tunnel_headers_received_called_ = true;
     on_tunnel_headers_received_origin_ = origin;
     on_tunnel_headers_received_proxy_server_ = proxy_server;
diff --git a/net/http/http_response_body_drainer_unittest.cc b/net/http/http_response_body_drainer_unittest.cc
index 5aa0bff..5a8713c 100644
--- a/net/http/http_response_body_drainer_unittest.cc
+++ b/net/http/http_response_body_drainer_unittest.cc
@@ -80,53 +80,53 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     return ERR_UNEXPECTED;
   }
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return ERR_UNEXPECTED;
   }
-  virtual UploadProgress GetUploadProgress() const OVERRIDE {
+  virtual UploadProgress GetUploadProgress() const override {
     return UploadProgress();
   }
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE {
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override {
     return ERR_UNEXPECTED;
   }
 
-  virtual bool CanFindEndOfResponse() const OVERRIDE { return true; }
-  virtual bool IsConnectionReused() const OVERRIDE { return false; }
-  virtual void SetConnectionReused() OVERRIDE {}
-  virtual bool IsConnectionReusable() const OVERRIDE { return false; }
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE { return 0; }
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {}
+  virtual bool CanFindEndOfResponse() const override { return true; }
+  virtual bool IsConnectionReused() const override { return false; }
+  virtual void SetConnectionReused() override {}
+  virtual bool IsConnectionReusable() const override { return false; }
+  virtual int64 GetTotalReceivedBytes() const override { return 0; }
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override {}
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE {}
+      SSLCertRequestInfo* cert_request_info) override {}
 
   // Mocked API
   virtual int ReadResponseBody(IOBuffer* buf, int buf_len,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual void Close(bool not_reusable) OVERRIDE {
+                               const CompletionCallback& callback) override;
+  virtual void Close(bool not_reusable) override {
     CHECK(!closed_);
     closed_ = true;
     result_waiter_->set_result(not_reusable);
   }
 
-  virtual HttpStream* RenewStreamForAuth() OVERRIDE {
+  virtual HttpStream* RenewStreamForAuth() override {
     return NULL;
   }
 
-  virtual bool IsResponseBodyComplete() const OVERRIDE { return is_complete_; }
+  virtual bool IsResponseBodyComplete() const override { return is_complete_; }
 
-  virtual bool IsSpdyHttpStream() const OVERRIDE { return false; }
+  virtual bool IsSpdyHttpStream() const override { return false; }
 
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE { return false; }
+      LoadTimingInfo* load_timing_info) const override { return false; }
 
-  virtual void Drain(HttpNetworkSession*) OVERRIDE {}
+  virtual void Drain(HttpNetworkSession*) override {}
 
-  virtual void SetPriority(RequestPriority priority) OVERRIDE {}
+  virtual void SetPriority(RequestPriority priority) override {}
 
   // Methods to tweak/observer mock behavior:
   void set_stall_reads_forever() { stall_reads_forever_ = true; }
diff --git a/net/http/http_server_properties_impl.h b/net/http/http_server_properties_impl.h
index 03bb75f..b68db36 100644
--- a/net/http/http_server_properties_impl.h
+++ b/net/http/http_server_properties_impl.h
@@ -69,95 +69,95 @@
   // -----------------------------
 
   // Gets a weak pointer for this object.
-  virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() OVERRIDE;
+  virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() override;
 
   // Deletes all data.
-  virtual void Clear() OVERRIDE;
+  virtual void Clear() override;
 
   // Returns true if |server| supports SPDY.
-  virtual bool SupportsSpdy(const HostPortPair& server) OVERRIDE;
+  virtual bool SupportsSpdy(const HostPortPair& server) override;
 
   // Add |server| into the persistent store.
   virtual void SetSupportsSpdy(const HostPortPair& server,
-                               bool support_spdy) OVERRIDE;
+                               bool support_spdy) override;
 
   // Returns true if |server| has an Alternate-Protocol header.
-  virtual bool HasAlternateProtocol(const HostPortPair& server) OVERRIDE;
+  virtual bool HasAlternateProtocol(const HostPortPair& server) override;
 
   // Returns the Alternate-Protocol and port for |server|.
   // HasAlternateProtocol(server) must be true.
   virtual AlternateProtocolInfo GetAlternateProtocol(
-      const HostPortPair& server) OVERRIDE;
+      const HostPortPair& server) override;
 
   // Sets the Alternate-Protocol for |server|.
   virtual void SetAlternateProtocol(
       const HostPortPair& server,
       uint16 alternate_port,
       AlternateProtocol alternate_protocol,
-      double probability) OVERRIDE;
+      double probability) override;
 
   // Sets the Alternate-Protocol for |server| to be BROKEN.
-  virtual void SetBrokenAlternateProtocol(const HostPortPair& server) OVERRIDE;
+  virtual void SetBrokenAlternateProtocol(const HostPortPair& server) override;
 
   // Returns true if Alternate-Protocol for |server| was recently BROKEN.
   virtual bool WasAlternateProtocolRecentlyBroken(
-      const HostPortPair& server) OVERRIDE;
+      const HostPortPair& server) override;
 
   // Confirms that Alternate-Protocol for |server| is working.
-  virtual void ConfirmAlternateProtocol(const HostPortPair& server) OVERRIDE;
+  virtual void ConfirmAlternateProtocol(const HostPortPair& server) override;
 
   // Clears the Alternate-Protocol for |server|.
-  virtual void ClearAlternateProtocol(const HostPortPair& server) OVERRIDE;
+  virtual void ClearAlternateProtocol(const HostPortPair& server) override;
 
   // Returns all Alternate-Protocol mappings.
-  virtual const AlternateProtocolMap& alternate_protocol_map() const OVERRIDE;
+  virtual const AlternateProtocolMap& alternate_protocol_map() const override;
 
   virtual void SetAlternateProtocolExperiment(
-      AlternateProtocolExperiment experiment) OVERRIDE;
+      AlternateProtocolExperiment experiment) override;
 
   virtual void SetAlternateProtocolProbabilityThreshold(
-      double threshold) OVERRIDE;
+      double threshold) override;
 
   virtual AlternateProtocolExperiment GetAlternateProtocolExperiment()
-      const OVERRIDE;
+      const override;
 
   // Gets a reference to the SettingsMap stored for a host.
   // If no settings are stored, returns an empty SettingsMap.
   virtual const SettingsMap& GetSpdySettings(
-      const HostPortPair& host_port_pair) OVERRIDE;
+      const HostPortPair& host_port_pair) override;
 
   // Saves an individual SPDY setting for a host. Returns true if SPDY setting
   // is to be persisted.
   virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
                               SpdySettingsIds id,
                               SpdySettingsFlags flags,
-                              uint32 value) OVERRIDE;
+                              uint32 value) override;
 
   // Clears all entries in |spdy_settings_map_| for a host.
-  virtual void ClearSpdySettings(const HostPortPair& host_port_pair) OVERRIDE;
+  virtual void ClearSpdySettings(const HostPortPair& host_port_pair) override;
 
   // Clears all entries in |spdy_settings_map_|.
-  virtual void ClearAllSpdySettings() OVERRIDE;
+  virtual void ClearAllSpdySettings() override;
 
   // Returns all persistent SPDY settings.
-  virtual const SpdySettingsMap& spdy_settings_map() const OVERRIDE;
+  virtual const SpdySettingsMap& spdy_settings_map() const override;
 
   // Methods for SupportsQuic.
   virtual SupportsQuic GetSupportsQuic(
-      const HostPortPair& host_port_pair) const OVERRIDE;
+      const HostPortPair& host_port_pair) const override;
 
   virtual void SetSupportsQuic(const HostPortPair& host_port_pair,
                                bool used_quic,
-                               const std::string& address) OVERRIDE;
+                               const std::string& address) override;
 
-  virtual const SupportsQuicMap& supports_quic_map() const OVERRIDE;
+  virtual const SupportsQuicMap& supports_quic_map() const override;
 
   // Methods for NetworkStats.
   virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
-                                     NetworkStats stats) OVERRIDE;
+                                     NetworkStats stats) override;
 
   virtual const NetworkStats* GetServerNetworkStats(
-      const HostPortPair& host_port_pair) const OVERRIDE;
+      const HostPortPair& host_port_pair) const override;
 
  private:
   // |spdy_servers_map_| has flattened representation of servers (host, port)
diff --git a/net/http/http_server_properties_manager.h b/net/http/http_server_properties_manager.h
index 6c2a8f8..bcfe320 100644
--- a/net/http/http_server_properties_manager.h
+++ b/net/http/http_server_properties_manager.h
@@ -78,96 +78,96 @@
   // ----------------------------------
 
   // Gets a weak pointer for this object.
-  virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() OVERRIDE;
+  virtual base::WeakPtr<HttpServerProperties> GetWeakPtr() override;
 
   // Deletes all data. Works asynchronously.
-  virtual void Clear() OVERRIDE;
+  virtual void Clear() override;
 
   // Returns true if |server| supports SPDY. Should only be called from IO
   // thread.
-  virtual bool SupportsSpdy(const HostPortPair& server) OVERRIDE;
+  virtual bool SupportsSpdy(const HostPortPair& server) override;
 
   // Add |server| as the SPDY server which supports SPDY protocol into the
   // persisitent store. Should only be called from IO thread.
   virtual void SetSupportsSpdy(const HostPortPair& server,
-                               bool support_spdy) OVERRIDE;
+                               bool support_spdy) override;
 
   // Returns true if |server| has an Alternate-Protocol header.
-  virtual bool HasAlternateProtocol(const HostPortPair& server) OVERRIDE;
+  virtual bool HasAlternateProtocol(const HostPortPair& server) override;
 
   // Returns the Alternate-Protocol and port for |server|.
   // HasAlternateProtocol(server) must be true.
   virtual AlternateProtocolInfo GetAlternateProtocol(
-      const HostPortPair& server) OVERRIDE;
+      const HostPortPair& server) override;
 
   // Sets the Alternate-Protocol for |server|.
   virtual void SetAlternateProtocol(
       const HostPortPair& server,
       uint16 alternate_port,
       AlternateProtocol alternate_protocol,
-      double alternate_probability) OVERRIDE;
+      double alternate_probability) override;
 
   // Sets the Alternate-Protocol for |server| to be BROKEN.
-  virtual void SetBrokenAlternateProtocol(const HostPortPair& server) OVERRIDE;
+  virtual void SetBrokenAlternateProtocol(const HostPortPair& server) override;
 
   // Returns true if Alternate-Protocol for |server| was recently BROKEN.
   virtual bool WasAlternateProtocolRecentlyBroken(
-      const HostPortPair& server) OVERRIDE;
+      const HostPortPair& server) override;
 
   // Confirms that Alternate-Protocol for |server| is working.
-  virtual void ConfirmAlternateProtocol(const HostPortPair& server) OVERRIDE;
+  virtual void ConfirmAlternateProtocol(const HostPortPair& server) override;
 
   // Clears the Alternate-Protocol for |server|.
-  virtual void ClearAlternateProtocol(const HostPortPair& server) OVERRIDE;
+  virtual void ClearAlternateProtocol(const HostPortPair& server) override;
 
   // Returns all Alternate-Protocol mappings.
-  virtual const AlternateProtocolMap& alternate_protocol_map() const OVERRIDE;
+  virtual const AlternateProtocolMap& alternate_protocol_map() const override;
 
   virtual void SetAlternateProtocolExperiment(
-      AlternateProtocolExperiment experiment) OVERRIDE;
+      AlternateProtocolExperiment experiment) override;
 
   virtual void SetAlternateProtocolProbabilityThreshold(
-      double threshold) OVERRIDE;
+      double threshold) override;
 
   virtual AlternateProtocolExperiment GetAlternateProtocolExperiment()
-      const OVERRIDE;
+      const override;
 
   // Gets a reference to the SettingsMap stored for a host.
   // If no settings are stored, returns an empty SettingsMap.
   virtual const SettingsMap& GetSpdySettings(
-      const HostPortPair& host_port_pair) OVERRIDE;
+      const HostPortPair& host_port_pair) override;
 
   // Saves an individual SPDY setting for a host. Returns true if SPDY setting
   // is to be persisted.
   virtual bool SetSpdySetting(const HostPortPair& host_port_pair,
                               SpdySettingsIds id,
                               SpdySettingsFlags flags,
-                              uint32 value) OVERRIDE;
+                              uint32 value) override;
 
   // Clears all SPDY settings for a host.
-  virtual void ClearSpdySettings(const HostPortPair& host_port_pair) OVERRIDE;
+  virtual void ClearSpdySettings(const HostPortPair& host_port_pair) override;
 
   // Clears all SPDY settings for all hosts.
-  virtual void ClearAllSpdySettings() OVERRIDE;
+  virtual void ClearAllSpdySettings() override;
 
   // Returns all SPDY persistent settings.
-  virtual const SpdySettingsMap& spdy_settings_map() const OVERRIDE;
+  virtual const SpdySettingsMap& spdy_settings_map() const override;
 
   // Methods for SupportsQuic.
   virtual SupportsQuic GetSupportsQuic(
-      const HostPortPair& host_port_pair) const OVERRIDE;
+      const HostPortPair& host_port_pair) const override;
 
   virtual void SetSupportsQuic(const HostPortPair& host_port_pair,
                                bool used_quic,
-                               const std::string& address) OVERRIDE;
+                               const std::string& address) override;
 
-  virtual const SupportsQuicMap& supports_quic_map() const OVERRIDE;
+  virtual const SupportsQuicMap& supports_quic_map() const override;
 
   virtual void SetServerNetworkStats(const HostPortPair& host_port_pair,
-                                     NetworkStats stats) OVERRIDE;
+                                     NetworkStats stats) override;
 
   virtual const NetworkStats* GetServerNetworkStats(
-      const HostPortPair& host_port_pair) const OVERRIDE;
+      const HostPortPair& host_port_pair) const override;
 
  protected:
   // --------------------
diff --git a/net/http/http_server_properties_manager_unittest.cc b/net/http/http_server_properties_manager_unittest.cc
index 012a46d..dbbfc2d 100644
--- a/net/http/http_server_properties_manager_unittest.cc
+++ b/net/http/http_server_properties_manager_unittest.cc
@@ -44,7 +44,7 @@
 
   // Post tasks without a delay during tests.
   virtual void StartPrefsUpdateTimerOnNetworkThread(
-      base::TimeDelta delay) OVERRIDE {
+      base::TimeDelta delay) override {
     HttpServerPropertiesManager::StartPrefsUpdateTimerOnNetworkThread(
         base::TimeDelta());
   }
@@ -55,7 +55,7 @@
 
   // Post tasks without a delay during tests.
   virtual void StartCacheUpdateTimerOnPrefThread(
-      base::TimeDelta delay) OVERRIDE {
+      base::TimeDelta delay) override {
     HttpServerPropertiesManager::StartCacheUpdateTimerOnPrefThread(
         base::TimeDelta());
   }
@@ -88,7 +88,7 @@
  protected:
   HttpServerPropertiesManagerTest() {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     pref_service_.registry()->RegisterDictionaryPref(kTestHttpServerProperties);
     http_server_props_manager_.reset(
         new StrictMock<TestingHttpServerPropertiesManager>(
@@ -99,7 +99,7 @@
     base::RunLoop().RunUntilIdle();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (http_server_props_manager_.get())
       http_server_props_manager_->ShutdownOnPrefThread();
     base::RunLoop().RunUntilIdle();
diff --git a/net/http/http_stream_factory_impl.h b/net/http/http_stream_factory_impl.h
index 7df0a67..91a59c2 100644
--- a/net/http/http_stream_factory_impl.h
+++ b/net/http/http_stream_factory_impl.h
@@ -38,7 +38,7 @@
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
-      const BoundNetLog& net_log) OVERRIDE;
+      const BoundNetLog& net_log) override;
 
   virtual HttpStreamRequest* RequestWebSocketHandshakeStream(
       const HttpRequestInfo& info,
@@ -47,14 +47,14 @@
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       WebSocketHandshakeStreamBase::CreateHelper* create_helper,
-      const BoundNetLog& net_log) OVERRIDE;
+      const BoundNetLog& net_log) override;
 
   virtual void PreconnectStreams(int num_streams,
                                  const HttpRequestInfo& info,
                                  RequestPriority priority,
                                  const SSLConfig& server_ssl_config,
-                                 const SSLConfig& proxy_ssl_config) OVERRIDE;
-  virtual const HostMappingRules* GetHostMappingRules() const OVERRIDE;
+                                 const SSLConfig& proxy_ssl_config) override;
+  virtual const HostMappingRules* GetHostMappingRules() const override;
 
   size_t num_orphaned_jobs() const { return orphaned_job_set_.size(); }
 
diff --git a/net/http/http_stream_factory_impl_request.h b/net/http/http_stream_factory_impl_request.h
index eafc138..3ab7d95 100644
--- a/net/http/http_stream_factory_impl_request.h
+++ b/net/http/http_stream_factory_impl_request.h
@@ -99,12 +99,12 @@
   // HttpStreamRequest methods.
 
   virtual int RestartTunnelWithProxyAuth(
-      const AuthCredentials& credentials) OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
-  virtual LoadState GetLoadState() const OVERRIDE;
-  virtual bool was_npn_negotiated() const OVERRIDE;
-  virtual NextProto protocol_negotiated() const OVERRIDE;
-  virtual bool using_spdy() const OVERRIDE;
+      const AuthCredentials& credentials) override;
+  virtual void SetPriority(RequestPriority priority) override;
+  virtual LoadState GetLoadState() const override;
+  virtual bool was_npn_negotiated() const override;
+  virtual NextProto protocol_negotiated() const override;
+  virtual bool using_spdy() const override;
 
  private:
   // Used to orphan all jobs in |jobs_| other than |job| which becomes "bound"
diff --git a/net/http/http_stream_factory_impl_request_unittest.cc b/net/http/http_stream_factory_impl_request_unittest.cc
index eea2a1b..422abd0 100644
--- a/net/http/http_stream_factory_impl_request_unittest.cc
+++ b/net/http/http_stream_factory_impl_request_unittest.cc
@@ -34,28 +34,28 @@
   virtual void OnStreamReady(
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
-      HttpStreamBase* stream) OVERRIDE {}
+      HttpStreamBase* stream) override {}
   virtual void OnWebSocketHandshakeStreamReady(
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
-      WebSocketHandshakeStreamBase* stream) OVERRIDE {}
+      WebSocketHandshakeStreamBase* stream) override {}
   virtual void OnStreamFailed(
       int status,
-      const SSLConfig& used_ssl_config) OVERRIDE {}
+      const SSLConfig& used_ssl_config) override {}
   virtual void OnCertificateError(
       int status,
       const SSLConfig& used_ssl_config,
-      const SSLInfo& ssl_info) OVERRIDE {}
+      const SSLInfo& ssl_info) override {}
   virtual void OnNeedsProxyAuth(const HttpResponseInfo& proxy_response,
                                 const SSLConfig& used_ssl_config,
                                 const ProxyInfo& used_proxy_info,
-                                HttpAuthController* auth_controller) OVERRIDE {}
+                                HttpAuthController* auth_controller) override {}
   virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
-                                 SSLCertRequestInfo* cert_info) OVERRIDE {}
+                                 SSLCertRequestInfo* cert_info) override {}
   virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
                                           const SSLConfig& used_ssl_config,
                                           const ProxyInfo& used_proxy_info,
-                                          HttpStreamBase* stream) OVERRIDE {}
+                                          HttpStreamBase* stream) override {}
 };
 
 }  // namespace
diff --git a/net/http/http_stream_factory_impl_unittest.cc b/net/http/http_stream_factory_impl_unittest.cc
index c56abfd..a93e9b0 100644
--- a/net/http/http_stream_factory_impl_unittest.cc
+++ b/net/http/http_stream_factory_impl_unittest.cc
@@ -62,41 +62,41 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE {
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
-  virtual void Close(bool not_reusable) OVERRIDE {}
-  virtual bool IsResponseBodyComplete() const OVERRIDE { return false; }
-  virtual bool CanFindEndOfResponse() const OVERRIDE { return false; }
-  virtual bool IsConnectionReused() const OVERRIDE { return false; }
-  virtual void SetConnectionReused() OVERRIDE {}
-  virtual bool IsConnectionReusable() const OVERRIDE { return false; }
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE { return 0; }
+  virtual void Close(bool not_reusable) override {}
+  virtual bool IsResponseBodyComplete() const override { return false; }
+  virtual bool CanFindEndOfResponse() const override { return false; }
+  virtual bool IsConnectionReused() const override { return false; }
+  virtual void SetConnectionReused() override {}
+  virtual bool IsConnectionReusable() const override { return false; }
+  virtual int64 GetTotalReceivedBytes() const override { return 0; }
   virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const
-      OVERRIDE {
+      override {
     return false;
   }
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {}
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override {}
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE {}
-  virtual bool IsSpdyHttpStream() const OVERRIDE { return false; }
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE {}
-  virtual void SetPriority(RequestPriority priority) OVERRIDE {}
+      SSLCertRequestInfo* cert_request_info) override {}
+  virtual bool IsSpdyHttpStream() const override { return false; }
+  virtual void Drain(HttpNetworkSession* session) override {}
+  virtual void SetPriority(RequestPriority priority) override {}
 
-  virtual scoped_ptr<WebSocketStream> Upgrade() OVERRIDE {
+  virtual scoped_ptr<WebSocketStream> Upgrade() override {
     return scoped_ptr<WebSocketStream>();
   }
 
@@ -124,7 +124,7 @@
 
  private:
   // HttpStreamFactoryImpl methods.
-  virtual void OnPreconnectsCompleteInternal() OVERRIDE {
+  virtual void OnPreconnectsCompleteInternal() override {
     preconnect_done_ = true;
     if (waiting_for_preconnect_)
       base::MessageLoop::current()->Quit();
@@ -145,7 +145,7 @@
   virtual void OnStreamReady(
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
-      HttpStreamBase* stream) OVERRIDE {
+      HttpStreamBase* stream) override {
     stream_done_ = true;
     if (waiting_for_stream_)
       base::MessageLoop::current()->Quit();
@@ -157,7 +157,7 @@
   virtual void OnWebSocketHandshakeStreamReady(
       const SSLConfig& used_ssl_config,
       const ProxyInfo& used_proxy_info,
-      WebSocketHandshakeStreamBase* stream) OVERRIDE {
+      WebSocketHandshakeStreamBase* stream) override {
     stream_done_ = true;
     if (waiting_for_stream_)
       base::MessageLoop::current()->Quit();
@@ -168,25 +168,25 @@
 
   virtual void OnStreamFailed(
       int status,
-      const SSLConfig& used_ssl_config) OVERRIDE {}
+      const SSLConfig& used_ssl_config) override {}
 
   virtual void OnCertificateError(
       int status,
       const SSLConfig& used_ssl_config,
-      const SSLInfo& ssl_info) OVERRIDE {}
+      const SSLInfo& ssl_info) override {}
 
   virtual void OnNeedsProxyAuth(const HttpResponseInfo& proxy_response,
                                 const SSLConfig& used_ssl_config,
                                 const ProxyInfo& used_proxy_info,
-                                HttpAuthController* auth_controller) OVERRIDE {}
+                                HttpAuthController* auth_controller) override {}
 
   virtual void OnNeedsClientAuth(const SSLConfig& used_ssl_config,
-                                 SSLCertRequestInfo* cert_info) OVERRIDE {}
+                                 SSLCertRequestInfo* cert_info) override {}
 
   virtual void OnHttpsProxyTunnelResponse(const HttpResponseInfo& response_info,
                                           const SSLConfig& used_ssl_config,
                                           const ProxyInfo& used_proxy_info,
-                                          HttpStreamBase* stream) OVERRIDE {}
+                                          HttpStreamBase* stream) override {}
 
   void WaitForStream() {
     while (!stream_done_) {
@@ -264,13 +264,13 @@
 
   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
-      bool using_proxy) OVERRIDE {
+      bool using_proxy) override {
     return new WebSocketBasicHandshakeStream(connection.Pass());
   }
 
   virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<SpdySession>& spdy_session,
-      bool use_relative_url) OVERRIDE {
+      bool use_relative_url) override {
     return new WebSocketSpdyHandshakeStream(spdy_session);
   }
 };
@@ -329,7 +329,7 @@
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE {
+                            const BoundNetLog& net_log) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
@@ -337,38 +337,38 @@
   virtual void RequestSockets(const std::string& group_name,
                               const void* socket_params,
                               int num_sockets,
-                              const BoundNetLog& net_log) OVERRIDE {
+                              const BoundNetLog& net_log) override {
     last_num_streams_ = num_sockets;
   }
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE {
+                             ClientSocketHandle* handle) override {
     ADD_FAILURE();
   }
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE {
+                             int id) override {
     ADD_FAILURE();
   }
-  virtual void CloseIdleSockets() OVERRIDE {
+  virtual void CloseIdleSockets() override {
     ADD_FAILURE();
   }
-  virtual int IdleSocketCount() const OVERRIDE {
+  virtual int IdleSocketCount() const override {
     ADD_FAILURE();
     return 0;
   }
   virtual int IdleSocketCountInGroup(
-      const std::string& group_name) const OVERRIDE {
+      const std::string& group_name) const override {
     ADD_FAILURE();
     return 0;
   }
   virtual LoadState GetLoadState(
       const std::string& group_name,
-      const ClientSocketHandle* handle) const OVERRIDE {
+      const ClientSocketHandle* handle) const override {
     ADD_FAILURE();
     return LOAD_STATE_IDLE;
   }
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
+  virtual base::TimeDelta ConnectionTimeout() const override {
     return base::TimeDelta();
   }
 
diff --git a/net/http/http_stream_parser.cc b/net/http/http_stream_parser.cc
index 86b188b..4a60a6b 100644
--- a/net/http/http_stream_parser.cc
+++ b/net/http/http_stream_parser.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "net/base/io_buffer.h"
@@ -357,6 +358,11 @@
 }
 
 void HttpStreamParser::OnIOComplete(int result) {
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "418183 DidCompleteReadWrite => HttpStreamParser::OnIOComplete"));
+
   result = DoLoop(result);
 
   // The client callback can do anything, including destroying this class,
diff --git a/net/http/http_stream_parser_unittest.cc b/net/http/http_stream_parser_unittest.cc
index 38279a4..ef83638 100644
--- a/net/http/http_stream_parser_unittest.cc
+++ b/net/http/http_stream_parser_unittest.cc
@@ -15,11 +15,12 @@
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
+#include "net/base/chunked_upload_data_stream.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
@@ -106,7 +107,7 @@
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_EmptyBody) {
   ScopedVector<UploadElementReader> element_readers;
   scoped_ptr<UploadDataStream> body(
-      new UploadDataStream(element_readers.Pass(), 0));
+      new ElementsUploadDataStream(element_readers.Pass(), 0));
   ASSERT_EQ(OK, body->Init(CompletionCallback()));
   // Shouldn't be merged if upload data is empty.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
@@ -115,10 +116,9 @@
 
 TEST(HttpStreamParser, ShouldMergeRequestHeadersAndBody_ChunkedBody) {
   const std::string payload = "123";
-  scoped_ptr<UploadDataStream> body(
-      new UploadDataStream(UploadDataStream::CHUNKED, 0));
-  body->AppendChunk(payload.data(), payload.size(), true);
-  ASSERT_EQ(OK, body->Init(CompletionCallback()));
+  scoped_ptr<ChunkedUploadDataStream> body(new ChunkedUploadDataStream(0));
+  body->AppendData(payload.data(), payload.size(), true);
+  ASSERT_EQ(OK, body->Init(TestCompletionCallback().callback()));
   // Shouldn't be merged if upload data carries chunked data.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
       "some header", body.get()));
@@ -143,7 +143,7 @@
                                     base::Time()));
 
     scoped_ptr<UploadDataStream> body(
-        new UploadDataStream(element_readers.Pass(), 0));
+        new ElementsUploadDataStream(element_readers.Pass(), 0));
     TestCompletionCallback callback;
     ASSERT_EQ(ERR_IO_PENDING, body->Init(callback.callback()));
     ASSERT_EQ(OK, callback.WaitForResult());
@@ -162,7 +162,7 @@
       payload.data(), payload.size()));
 
   scoped_ptr<UploadDataStream> body(
-      new UploadDataStream(element_readers.Pass(), 0));
+      new ElementsUploadDataStream(element_readers.Pass(), 0));
   ASSERT_EQ(OK, body->Init(CompletionCallback()));
   // Yes, should be merged if the in-memory body is small here.
   ASSERT_TRUE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
@@ -176,7 +176,7 @@
       payload.data(), payload.size()));
 
   scoped_ptr<UploadDataStream> body(
-      new UploadDataStream(element_readers.Pass(), 0));
+      new ElementsUploadDataStream(element_readers.Pass(), 0));
   ASSERT_EQ(OK, body->Init(CompletionCallback()));
   // Shouldn't be merged if the in-memory body is large here.
   ASSERT_FALSE(HttpStreamParser::ShouldMergeRequestHeadersAndBody(
@@ -218,9 +218,9 @@
     MockRead(SYNCHRONOUS, 0, 8),  // EOF
   };
 
-  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
-  upload_stream.AppendChunk(kChunk1, arraysize(kChunk1) - 1, false);
-  ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
+  ChunkedUploadDataStream upload_stream(0);
+  upload_stream.AppendData(kChunk1, arraysize(kChunk1) - 1, false);
+  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
 
   DeterministicSocketData data(reads, arraysize(reads),
                                writes, arraysize(writes));
@@ -267,7 +267,7 @@
 
   // Now append another chunk (while the first write is still pending), which
   // should not confuse the state machine.
-  upload_stream.AppendChunk(kChunk2, arraysize(kChunk2) - 1, false);
+  upload_stream.AppendData(kChunk2, arraysize(kChunk2) - 1, false);
   ASSERT_FALSE(callback.have_result());
 
   // Complete writing the first chunk, which should then enqueue the second
@@ -284,7 +284,7 @@
 
   // Add the final chunk. This will enqueue another write, but it will not
   // complete due to the async nature.
-  upload_stream.AppendChunk(kChunk3, arraysize(kChunk3) - 1, true);
+  upload_stream.AppendData(kChunk3, arraysize(kChunk3) - 1, true);
   ASSERT_FALSE(callback.have_result());
 
   // Finalize writing the last chunk, which will enqueue the trailer.
diff --git a/net/http/http_transaction_test_util.h b/net/http/http_transaction_test_util.h
index b8663c6..e0f5bda 100644
--- a/net/http/http_transaction_test_util.h
+++ b/net/http/http_transaction_test_util.h
@@ -172,57 +172,57 @@
 
   virtual int Start(const net::HttpRequestInfo* request,
                     const net::CompletionCallback& callback,
-                    const net::BoundNetLog& net_log) OVERRIDE;
+                    const net::BoundNetLog& net_log) override;
 
   virtual int RestartIgnoringLastError(
-      const net::CompletionCallback& callback) OVERRIDE;
+      const net::CompletionCallback& callback) override;
 
   virtual int RestartWithCertificate(
       net::X509Certificate* client_cert,
-      const net::CompletionCallback& callback) OVERRIDE;
+      const net::CompletionCallback& callback) override;
 
   virtual int RestartWithAuth(
       const net::AuthCredentials& credentials,
-      const net::CompletionCallback& callback) OVERRIDE;
+      const net::CompletionCallback& callback) override;
 
-  virtual bool IsReadyToRestartForAuth() OVERRIDE;
+  virtual bool IsReadyToRestartForAuth() override;
 
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   const net::CompletionCallback& callback) OVERRIDE;
+                   const net::CompletionCallback& callback) override;
 
-  virtual void StopCaching() OVERRIDE;
+  virtual void StopCaching() override;
 
   virtual bool GetFullRequestHeaders(
-      net::HttpRequestHeaders* headers) const OVERRIDE;
+      net::HttpRequestHeaders* headers) const override;
 
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+  virtual int64 GetTotalReceivedBytes() const override;
 
-  virtual void DoneReading() OVERRIDE;
+  virtual void DoneReading() override;
 
-  virtual const net::HttpResponseInfo* GetResponseInfo() const OVERRIDE;
+  virtual const net::HttpResponseInfo* GetResponseInfo() const override;
 
-  virtual net::LoadState GetLoadState() const OVERRIDE;
+  virtual net::LoadState GetLoadState() const override;
 
-  virtual net::UploadProgress GetUploadProgress() const OVERRIDE;
+  virtual net::UploadProgress GetUploadProgress() const override;
 
   virtual void SetQuicServerInfo(
-      net::QuicServerInfo* quic_server_info) OVERRIDE;
+      net::QuicServerInfo* quic_server_info) override;
 
   virtual bool GetLoadTimingInfo(
-      net::LoadTimingInfo* load_timing_info) const OVERRIDE;
+      net::LoadTimingInfo* load_timing_info) const override;
 
-  virtual void SetPriority(net::RequestPriority priority) OVERRIDE;
+  virtual void SetPriority(net::RequestPriority priority) override;
 
   virtual void SetWebSocketHandshakeStreamCreateHelper(
-      CreateHelper* create_helper) OVERRIDE;
+      CreateHelper* create_helper) override;
 
   virtual void SetBeforeNetworkStartCallback(
-      const BeforeNetworkStartCallback& callback) OVERRIDE;
+      const BeforeNetworkStartCallback& callback) override;
 
   virtual void SetBeforeProxyHeadersSentCallback(
-      const BeforeProxyHeadersSentCallback& callback) OVERRIDE;
+      const BeforeProxyHeadersSentCallback& callback) override;
 
-  virtual int ResumeNetworkStart() OVERRIDE;
+  virtual int ResumeNetworkStart() override;
 
   CreateHelper* websocket_handshake_stream_create_helper() {
     return websocket_handshake_stream_create_helper_;
@@ -292,9 +292,9 @@
   // net::HttpTransactionFactory:
   virtual int CreateTransaction(
       net::RequestPriority priority,
-      scoped_ptr<net::HttpTransaction>* trans) OVERRIDE;
-  virtual net::HttpCache* GetCache() OVERRIDE;
-  virtual net::HttpNetworkSession* GetSession() OVERRIDE;
+      scoped_ptr<net::HttpTransaction>* trans) override;
+  virtual net::HttpCache* GetCache() override;
+  virtual net::HttpNetworkSession* GetSession() override;
 
  private:
   int transaction_count_;
diff --git a/net/http/mock_allow_url_security_manager.h b/net/http/mock_allow_url_security_manager.h
index 8fbe2c5..3e19f9b 100644
--- a/net/http/mock_allow_url_security_manager.h
+++ b/net/http/mock_allow_url_security_manager.h
@@ -16,8 +16,8 @@
   MockAllowURLSecurityManager();
   virtual ~MockAllowURLSecurityManager();
 
-  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const OVERRIDE;
-  virtual bool CanDelegate(const GURL& auth_origin) const OVERRIDE;
+  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const override;
+  virtual bool CanDelegate(const GURL& auth_origin) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAllowURLSecurityManager);
diff --git a/net/http/mock_gssapi_library_posix.h b/net/http/mock_gssapi_library_posix.h
index faecdd4..cbd35e5 100644
--- a/net/http/mock_gssapi_library_posix.h
+++ b/net/http/mock_gssapi_library_posix.h
@@ -122,32 +122,32 @@
   // Initializes the library, including any necessary dynamic libraries.
   // This is done separately from construction (which happens at startup time)
   // in order to delay work until the class is actually needed.
-  virtual bool Init() OVERRIDE;
+  virtual bool Init() override;
 
   // These methods match the ones in the GSSAPI library.
   virtual OM_uint32 import_name(
       OM_uint32* minor_status,
       const gss_buffer_t input_name_buffer,
       const gss_OID input_name_type,
-      gss_name_t* output_name) OVERRIDE;
+      gss_name_t* output_name) override;
   virtual OM_uint32 release_name(
       OM_uint32* minor_status,
-      gss_name_t* input_name) OVERRIDE;
+      gss_name_t* input_name) override;
   virtual OM_uint32 release_buffer(
       OM_uint32* minor_status,
-      gss_buffer_t buffer) OVERRIDE;
+      gss_buffer_t buffer) override;
   virtual OM_uint32 display_name(
       OM_uint32* minor_status,
       const gss_name_t input_name,
       gss_buffer_t output_name_buffer,
-      gss_OID* output_name_type) OVERRIDE;
+      gss_OID* output_name_type) override;
   virtual OM_uint32 display_status(
       OM_uint32* minor_status,
       OM_uint32 status_value,
       int status_type,
       const gss_OID mech_type,
       OM_uint32* message_contex,
-      gss_buffer_t status_string) OVERRIDE;
+      gss_buffer_t status_string) override;
   virtual OM_uint32 init_sec_context(
       OM_uint32* minor_status,
       const gss_cred_id_t initiator_cred_handle,
@@ -161,18 +161,18 @@
       gss_OID* actual_mech_type,
       gss_buffer_t output_token,
       OM_uint32* ret_flags,
-      OM_uint32* time_rec) OVERRIDE;
+      OM_uint32* time_rec) override;
   virtual OM_uint32 wrap_size_limit(
       OM_uint32* minor_status,
       const gss_ctx_id_t context_handle,
       int conf_req_flag,
       gss_qop_t qop_req,
       OM_uint32 req_output_size,
-      OM_uint32* max_input_size) OVERRIDE;
+      OM_uint32* max_input_size) override;
   virtual OM_uint32 delete_sec_context(
       OM_uint32* minor_status,
       gss_ctx_id_t* context_handle,
-      gss_buffer_t output_token) OVERRIDE;
+      gss_buffer_t output_token) override;
   virtual OM_uint32 inquire_context(
       OM_uint32* minor_status,
       const gss_ctx_id_t context_handle,
@@ -182,7 +182,7 @@
       gss_OID* mech_type,
       OM_uint32* ctx_flags,
       int* locally_initiated,
-      int* open) OVERRIDE;
+      int* open) override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpAuthGSSAPIPOSIXTest, GSSAPICycle);
diff --git a/net/http/mock_http_cache.cc b/net/http/mock_http_cache.cc
index cbae9b8..325454e 100644
--- a/net/http/mock_http_cache.cc
+++ b/net/http/mock_http_cache.cc
@@ -460,7 +460,7 @@
 class MockDiskCache::NotImplementedIterator : public Iterator {
  public:
   virtual int OpenNextEntry(disk_cache::Entry** next_entry,
-                            const net::CompletionCallback& callback) OVERRIDE {
+                            const net::CompletionCallback& callback) override {
     return net::ERR_NOT_IMPLEMENTED;
   }
 };
diff --git a/net/http/mock_http_cache.h b/net/http/mock_http_cache.h
index ab63b11..9b2caf5 100644
--- a/net/http/mock_http_cache.h
+++ b/net/http/mock_http_cache.h
@@ -25,29 +25,29 @@
 
   bool is_doomed() const { return doomed_; }
 
-  virtual void Doom() OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetKey() const OVERRIDE;
-  virtual base::Time GetLastUsed() const OVERRIDE;
-  virtual base::Time GetLastModified() const OVERRIDE;
-  virtual int32 GetDataSize(int index) const OVERRIDE;
+  virtual void Doom() override;
+  virtual void Close() override;
+  virtual std::string GetKey() const override;
+  virtual base::Time GetLastUsed() const override;
+  virtual base::Time GetLastModified() const override;
+  virtual int32 GetDataSize(int index) const override;
   virtual int ReadData(int index, int offset, net::IOBuffer* buf, int buf_len,
-                       const net::CompletionCallback& callback) OVERRIDE;
+                       const net::CompletionCallback& callback) override;
   virtual int WriteData(int index, int offset, net::IOBuffer* buf, int buf_len,
                         const net::CompletionCallback& callback,
-                        bool truncate) OVERRIDE;
+                        bool truncate) override;
   virtual int ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
-                             const net::CompletionCallback& callback) OVERRIDE;
+                             const net::CompletionCallback& callback) override;
   virtual int WriteSparseData(
       int64 offset, net::IOBuffer* buf, int buf_len,
-      const net::CompletionCallback& callback) OVERRIDE;
+      const net::CompletionCallback& callback) override;
   virtual int GetAvailableRange(
       int64 offset, int len, int64* start,
-      const net::CompletionCallback& callback) OVERRIDE;
-  virtual bool CouldBeSparse() const OVERRIDE;
-  virtual void CancelSparseIO() OVERRIDE;
+      const net::CompletionCallback& callback) override;
+  virtual bool CouldBeSparse() const override;
+  virtual void CancelSparseIO() override;
   virtual int ReadyForSparseIO(
-      const net::CompletionCallback& completion_callback) OVERRIDE;
+      const net::CompletionCallback& completion_callback) override;
 
   // Fail most subsequent requests.
   void set_fail_requests() { fail_requests_ = true; }
@@ -98,26 +98,26 @@
   MockDiskCache();
   virtual ~MockDiskCache();
 
-  virtual net::CacheType GetCacheType() const OVERRIDE;
-  virtual int32 GetEntryCount() const OVERRIDE;
+  virtual net::CacheType GetCacheType() const override;
+  virtual int32 GetEntryCount() const override;
   virtual int OpenEntry(const std::string& key, disk_cache::Entry** entry,
-                        const net::CompletionCallback& callback) OVERRIDE;
+                        const net::CompletionCallback& callback) override;
   virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
-                          const net::CompletionCallback& callback) OVERRIDE;
+                          const net::CompletionCallback& callback) override;
   virtual int DoomEntry(const std::string& key,
-                        const net::CompletionCallback& callback) OVERRIDE;
-  virtual int DoomAllEntries(const net::CompletionCallback& callback) OVERRIDE;
+                        const net::CompletionCallback& callback) override;
+  virtual int DoomAllEntries(const net::CompletionCallback& callback) override;
   virtual int DoomEntriesBetween(
       base::Time initial_time,
       base::Time end_time,
-      const net::CompletionCallback& callback) OVERRIDE;
+      const net::CompletionCallback& callback) override;
   virtual int DoomEntriesSince(
       base::Time initial_time,
-      const net::CompletionCallback& callback) OVERRIDE;
-  virtual scoped_ptr<Iterator> CreateIterator() OVERRIDE;
+      const net::CompletionCallback& callback) override;
+  virtual scoped_ptr<Iterator> CreateIterator() override;
   virtual void GetStats(
-      std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE;
-  virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
+      std::vector<std::pair<std::string, std::string> >* stats) override;
+  virtual void OnExternalCacheHit(const std::string& key) override;
 
   // Returns number of times a cache entry was successfully opened.
   int open_count() const { return open_count_; }
@@ -158,7 +158,7 @@
  public:
   virtual int CreateBackend(net::NetLog* net_log,
                             scoped_ptr<disk_cache::Backend>* backend,
-                            const net::CompletionCallback& callback) OVERRIDE;
+                            const net::CompletionCallback& callback) override;
 };
 
 class MockHttpCache {
@@ -211,14 +211,14 @@
 // This version of the disk cache doesn't invoke CreateEntry callbacks.
 class MockDiskCacheNoCB : public MockDiskCache {
   virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
-                          const net::CompletionCallback& callback) OVERRIDE;
+                          const net::CompletionCallback& callback) override;
 };
 
 class MockBackendNoCbFactory : public net::HttpCache::BackendFactory {
  public:
   virtual int CreateBackend(net::NetLog* net_log,
                             scoped_ptr<disk_cache::Backend>* backend,
-                            const net::CompletionCallback& callback) OVERRIDE;
+                            const net::CompletionCallback& callback) override;
 };
 
 // This backend factory allows us to control the backend instantiation.
@@ -229,7 +229,7 @@
 
   virtual int CreateBackend(net::NetLog* net_log,
                             scoped_ptr<disk_cache::Backend>* backend,
-                            const net::CompletionCallback& callback) OVERRIDE;
+                            const net::CompletionCallback& callback) override;
 
   // Completes the backend creation. Any blocked call will be notified via the
   // provided callback.
diff --git a/net/http/partial_data.cc b/net/http/partial_data.cc
index c7cde99..a453ba4 100644
--- a/net/http/partial_data.cc
+++ b/net/http/partial_data.cc
@@ -8,6 +8,7 @@
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ -89,6 +90,11 @@
 }
 
 void PartialData::Core::OnIOComplete(int result) {
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/422516 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "422516 PartialData::Core::OnIOComplete"));
+
   if (owner_)
     owner_->GetAvailableRangeCompleted(result, start_);
   delete this;
diff --git a/net/http/proxy_connect_redirect_http_stream.h b/net/http/proxy_connect_redirect_http_stream.h
index f848c64..ddaf9b7 100644
--- a/net/http/proxy_connect_redirect_http_stream.h
+++ b/net/http/proxy_connect_redirect_http_stream.h
@@ -28,44 +28,44 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE;
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override;
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
 
   // This function may be called.
-  virtual void Close(bool not_reusable) OVERRIDE;
+  virtual void Close(bool not_reusable) override;
 
-  virtual bool IsResponseBodyComplete() const OVERRIDE;
+  virtual bool IsResponseBodyComplete() const override;
 
   // This function may be called.
-  virtual bool CanFindEndOfResponse() const OVERRIDE;
+  virtual bool CanFindEndOfResponse() const override;
 
-  virtual bool IsConnectionReused() const OVERRIDE;
-  virtual void SetConnectionReused() OVERRIDE;
-  virtual bool IsConnectionReusable() const OVERRIDE;
+  virtual bool IsConnectionReused() const override;
+  virtual void SetConnectionReused() override;
+  virtual bool IsConnectionReusable() const override;
 
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+  virtual int64 GetTotalReceivedBytes() const override;
 
   // This function may be called.
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
 
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override;
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
-  virtual bool IsSpdyHttpStream() const OVERRIDE;
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
+  virtual bool IsSpdyHttpStream() const override;
+  virtual void Drain(HttpNetworkSession* session) override;
 
   // This function may be called.
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+  virtual void SetPriority(RequestPriority priority) override;
 
-  virtual UploadProgress GetUploadProgress() const OVERRIDE;
-  virtual HttpStream* RenewStreamForAuth() OVERRIDE;
+  virtual UploadProgress GetUploadProgress() const override;
+  virtual HttpStream* RenewStreamForAuth() override;
 
  private:
   bool has_load_timing_info_;
diff --git a/net/http/transport_security_persister.h b/net/http/transport_security_persister.h
index 79a0d7a..5081c38 100644
--- a/net/http/transport_security_persister.h
+++ b/net/http/transport_security_persister.h
@@ -65,7 +65,7 @@
   virtual ~TransportSecurityPersister();
 
   // Called by the TransportSecurityState when it changes its state.
-  virtual void StateIsDirty(TransportSecurityState*) OVERRIDE;
+  virtual void StateIsDirty(TransportSecurityState*) override;
 
   // ImportantFileWriter::DataSerializer:
   //
@@ -97,7 +97,7 @@
   // The reason for hashing them is so that the stored state does not
   // trivially reveal a user's browsing history to an attacker reading the
   // serialized state on disk.
-  virtual bool SerializeData(std::string* data) OVERRIDE;
+  virtual bool SerializeData(std::string* data) override;
 
   // Clears any existing non-static entries, and then re-populates
   // |transport_security_state_|.
diff --git a/net/http/transport_security_persister_unittest.cc b/net/http/transport_security_persister_unittest.cc
index f4d49f7..b8dad5a 100644
--- a/net/http/transport_security_persister_unittest.cc
+++ b/net/http/transport_security_persister_unittest.cc
@@ -27,7 +27,7 @@
     base::MessageLoopForIO::current()->RunUntilIdle();
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     persister_.reset(new TransportSecurityPersister(
         &state_,
diff --git a/net/http/transport_security_state_static.h b/net/http/transport_security_state_static.h
index f1bec20..edbe166 100644
--- a/net/http/transport_security_state_static.h
+++ b/net/http/transport_security_state_static.h
@@ -672,1327 +672,1368 @@
 // value has the MSB set then it represents a literal leaf value. Otherwise
 // it's a pointer to the n'th element of the array.
 static const uint8 kHSTSHuffmanTree[] = {
-  0xad, 0xf9, 0x00, 0xf7, 0x01, 0xec, 0x02, 0x80,
-  0xb3, 0xb1, 0xf1, 0x04, 0xb4, 0x05, 0x06, 0xf8,
-  0xf6, 0x07, 0xeb, 0x08, 0xed, 0x09, 0xe1, 0x0a,
-  0xe2, 0xe8, 0xe3, 0x0c, 0xe7, 0x0d, 0x0b, 0x0e,
-  0x03, 0x0f, 0xee, 0xf3, 0xb9, 0xb6, 0x12, 0xb7,
-  0xb5, 0x13, 0xb0, 0x14, 0x15, 0xb2, 0x16, 0xea,
-  0xfa, 0x17, 0x18, 0xe6, 0x19, 0xf5, 0xae, 0x1a,
-  0x11, 0x1b, 0xff, 0x1c, 0xf4, 0xe9, 0xe5, 0x1e,
-  0xe4, 0xf0, 0x20, 0xf2, 0x21, 0xef, 0x1f, 0x22,
-  0x1d, 0x23, 0x10, 0x24,
+  0xf0, 0xf7, 0x00, 0xec, 0x01, 0x80, 0xb3, 0xb0,
+  0x03, 0xf1, 0xb4, 0x04, 0x05, 0xf8, 0xf6, 0x06,
+  0xeb, 0x07, 0xed, 0x08, 0xe1, 0x09, 0xe2, 0xe8,
+  0xe3, 0x0b, 0xe7, 0x0c, 0x0a, 0x0d, 0x02, 0x0e,
+  0xf3, 0xee, 0xb9, 0xb6, 0x11, 0xb7, 0xb5, 0x12,
+  0xb1, 0x13, 0x14, 0xb2, 0x15, 0xea, 0xfa, 0x16,
+  0x17, 0xe6, 0xf5, 0x18, 0xae, 0x19, 0x10, 0x1a,
+  0xff, 0x1b, 0xf4, 0xe9, 0xe5, 0x1d, 0xad, 0xf9,
+  0xe4, 0x1f, 0x20, 0xf2, 0x21, 0xef, 0x1e, 0x22,
+  0x1c, 0x23, 0x0f, 0x24,
 };
 
 static const uint8 kPreloadedHSTSData[] = {
   0xfe, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x25, 0x9f,
   0x0b, 0x7f, 0xb1, 0xa2, 0x2d, 0x9b, 0x1f, 0x2a,
-  0x48, 0x54, 0xb9, 0x13, 0x4b, 0xc8, 0xb4, 0xfe,
-  0xd6, 0x0f, 0x2a, 0xdd, 0x4a, 0xb1, 0xa8, 0x9f,
-  0x9d, 0x4d, 0xae, 0xc5, 0x8e, 0x84, 0x3f, 0x3f,
-  0x43, 0x95, 0xb1, 0x31, 0x05, 0xf8, 0x78, 0x4f,
-  0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x2a, 0x29, 0xf0,
-  0xb7, 0xfb, 0x1a, 0x2b, 0xd9, 0xf6, 0xee, 0x1a,
-  0xf7, 0x8e, 0x95, 0xb0, 0xf7, 0x04, 0xc2, 0x7f,
-  0xeb, 0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68, 0x91,
-  0xa7, 0xff, 0x59, 0x5e, 0xeb, 0x60, 0xb7, 0xfb,
-  0x1a, 0x27, 0x89, 0xff, 0xd6, 0x57, 0xba, 0xd8,
-  0x2d, 0xfe, 0xc6, 0x89, 0xfe, 0x7f, 0xf5, 0x95,
-  0xee, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x86, 0x9f,
-  0xfd, 0x65, 0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68,
-  0xa2, 0x27, 0xfd, 0xee, 0xb6, 0x0b, 0x7f, 0xb1,
-  0xa2, 0x91, 0x9f, 0xff, 0xb3, 0x8a, 0x20, 0x36,
-  0xd7, 0x7f, 0x9a, 0xd5, 0x39, 0x2a, 0x56, 0x52,
-  0x29, 0x17, 0xd1, 0xa7, 0xfe, 0xb7, 0xba, 0xd8,
-  0x2d, 0xfe, 0xc6, 0x89, 0x42, 0x1e, 0x5c, 0xe9,
-  0x74, 0x69, 0x6c, 0x62, 0x30, 0x97, 0x51, 0x35,
-  0x13, 0x39, 0x52, 0x5e, 0x94, 0xaa, 0xa5, 0x7c,
-  0x3d, 0xae, 0x0b, 0x27, 0xff, 0x59, 0x5e, 0xeb,
-  0x60, 0xb7, 0xfb, 0x1a, 0x27, 0x39, 0xff, 0xd6,
-  0x57, 0xba, 0xd8, 0x2d, 0xfe, 0xc6, 0x8a, 0x26,
-  0x7f, 0xe1, 0x75, 0xa9, 0xba, 0xac, 0xed, 0xf2,
-  0x74, 0x0a, 0x3a, 0xea, 0xa5, 0x7a, 0x94, 0xfe,
-  0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x1c, 0x9f, 0x0b,
-  0x7f, 0xb1, 0xa2, 0x2f, 0x9f, 0x7e, 0x9c, 0x97,
-  0x4a, 0x95, 0xb0, 0xf6, 0x3a, 0x61, 0x3f, 0xfa,
-  0xca, 0xf7, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x32,
-  0x4f, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x2d, 0xe9,
-  0xff, 0xd6, 0x57, 0xba, 0xd8, 0x2d, 0xfe, 0xc6,
-  0x8a, 0x4e, 0x11, 0x39, 0x97, 0x42, 0x4f, 0x09,
-  0xea, 0xa4, 0xb8, 0xee, 0x7f, 0x5b, 0x05, 0xbf,
-  0xd8, 0xd1, 0x0e, 0xcf, 0xfe, 0xb2, 0xbd, 0xd6,
-  0xc1, 0x6f, 0xf6, 0x34, 0x4b, 0x13, 0xfa, 0xd8,
-  0x2d, 0xfe, 0xc6, 0x88, 0xc2, 0x7f, 0xeb, 0x7b,
-  0xad, 0x82, 0xdf, 0xec, 0x68, 0x8f, 0x67, 0xf5,
-  0xb0, 0x5b, 0xfd, 0x8d, 0x16, 0x1c, 0xfe, 0xb6,
-  0x0b, 0x7f, 0xb1, 0xa2, 0xe7, 0x84, 0x4e, 0x29,
-  0xe3, 0xb7, 0x29, 0x6c, 0xed, 0x49, 0x9a, 0x3b,
-  0x9f, 0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x43, 0xd3,
-  0xe1, 0x6f, 0xf6, 0x34, 0x44, 0xd3, 0x69, 0x47,
-  0x4f, 0xfe, 0xca, 0x02, 0xf5, 0x53, 0x6f, 0xe9,
-  0x14, 0x74, 0x3e, 0x7c, 0x54, 0x16, 0x9e, 0xd5,
-  0xfe, 0x09, 0xa2, 0x17, 0x95, 0xb1, 0x1c, 0xb5,
-  0x84, 0x95, 0xe4, 0x73, 0xda, 0xa6, 0xf4, 0x74,
-  0xff, 0xed, 0xac, 0xec, 0x7d, 0xc0, 0x2b, 0xff,
-  0xa7, 0x4d, 0xf7, 0x07, 0x4a, 0xe5, 0xc4, 0x43,
-  0x50, 0x8b, 0xd3, 0x27, 0xd4, 0xfd, 0x7b, 0x8e,
-  0x9e, 0xdd, 0x77, 0xc9, 0xd3, 0x82, 0x10, 0x95,
-  0x3e, 0xfe, 0xea, 0x98, 0x55, 0x8b, 0xc9, 0xf7,
-  0xe9, 0x6c, 0xd1, 0xd1, 0xc2, 0x26, 0xf9, 0x3f,
-  0xe9, 0xac, 0xff, 0xdc, 0xed, 0x60, 0x28, 0x9b,
-  0x1b, 0xee, 0x67, 0x4f, 0xfb, 0x77, 0x53, 0xa9,
-  0x54, 0xda, 0x8e, 0x9f, 0xb1, 0x75, 0xee, 0xca,
-  0x9d, 0x3d, 0x9c, 0x63, 0xc7, 0x46, 0x27, 0x9f,
-  0xb8, 0x60, 0xac, 0x65, 0x44, 0xce, 0x9f, 0xe8,
-  0xbe, 0x7e, 0xc0, 0xa6, 0x71, 0xb3, 0xa7, 0xff,
-  0xff, 0x77, 0xaf, 0xa5, 0xde, 0xe7, 0x14, 0xda,
-  0xc0, 0x57, 0x1f, 0x70, 0xe0, 0x4e, 0x9f, 0x6f,
-  0x57, 0xa3, 0xc7, 0x4f, 0xe7, 0xdd, 0x5b, 0xb7,
-  0xa3, 0xe7, 0x4f, 0xef, 0x0d, 0xeb, 0x26, 0xbc,
-  0xe8, 0xd9, 0xf5, 0xf4, 0xe2, 0x11, 0x33, 0x4c,
-  0x7e, 0x18, 0x4a, 0x4d, 0x7b, 0x8e, 0x9d, 0xfa,
-  0xa9, 0xd3, 0x5e, 0xf1, 0xd3, 0xc9, 0xdd, 0x2c,
-  0xe3, 0x66, 0x23, 0x73, 0xff, 0xeb, 0xd3, 0x40,
-  0x76, 0xfb, 0x80, 0x33, 0x4b, 0xf9, 0xa3, 0xa7,
-  0xfe, 0xa2, 0x5d, 0x03, 0x5d, 0xfd, 0x26, 0x8e,
-  0x9f, 0xc0, 0x3e, 0xed, 0xd2, 0xf5, 0x1d, 0x1c,
-  0x9f, 0xef, 0x51, 0xa7, 0xfc, 0x2b, 0x01, 0x54,
-  0xdb, 0xdf, 0xa3, 0xa1, 0x0f, 0x8e, 0xf2, 0x39,
-  0xff, 0xff, 0xeb, 0xfb, 0x51, 0xea, 0x2c, 0x00,
-  0x3a, 0xdb, 0xb1, 0xfd, 0x62, 0xee, 0xe5, 0x4e,
-  0x92, 0x1d, 0x3f, 0x9d, 0xe3, 0xba, 0xa3, 0xe7,
-  0x4f, 0xff, 0xff, 0xed, 0xf3, 0x5e, 0xe7, 0xbe,
-  0x07, 0x14, 0xbc, 0x0e, 0xe3, 0xee, 0xcb, 0xde,
-  0xee, 0x7b, 0xe7, 0x4e, 0xff, 0x63, 0x45, 0x31,
-  0x18, 0x8b, 0xe6, 0x84, 0xc4, 0xff, 0xb3, 0xaf,
-  0xba, 0xba, 0x41, 0x58, 0xe9, 0xf3, 0xfd, 0xc5,
-  0xd8, 0x74, 0x6c, 0xfa, 0x3c, 0xfe, 0x7f, 0xbd,
-  0x5c, 0x51, 0x1e, 0xc0, 0x9d, 0x3f, 0xff, 0xbb,
-  0x8d, 0xad, 0x26, 0xaa, 0xb7, 0x70, 0x20, 0x22,
-  0xf7, 0x3a, 0x7f, 0xcc, 0x8a, 0xa6, 0x57, 0x37,
-  0xd3, 0xa1, 0x11, 0x47, 0x46, 0x79, 0xf0, 0xa2,
-  0xe4, 0x13, 0xa7, 0xef, 0xe8, 0x1c, 0x27, 0x4e,
-  0x8c, 0x3f, 0x6d, 0x91, 0x5e, 0x4d, 0x0f, 0x2e,
-  0xcb, 0x70, 0x95, 0x74, 0xe1, 0xa3, 0x3f, 0x7c,
-  0x8b, 0x70, 0x84, 0x58, 0x3c, 0x61, 0xe0, 0xa8,
-  0x47, 0x74, 0x87, 0x51, 0xa9, 0x4f, 0x67, 0x6e,
-  0xdc, 0xce, 0x9f, 0xff, 0xff, 0x53, 0x7a, 0xa6,
-  0x0a, 0x2e, 0x01, 0x57, 0xdc, 0x01, 0x8f, 0xbb,
-  0x2f, 0xef, 0x35, 0x3a, 0x5a, 0xda, 0x2d, 0x6a,
-  0x4f, 0x3f, 0xfe, 0xcc, 0xa6, 0xda, 0x98, 0x05,
-  0x6f, 0xa2, 0x5c, 0xce, 0x9f, 0xfa, 0xbe, 0xf8,
-  0x0a, 0x4c, 0xee, 0x97, 0xce, 0x96, 0xfa, 0x8a,
-  0x1d, 0x2c, 0xcf, 0x9c, 0x8f, 0xba, 0xa7, 0x4f,
-  0xff, 0xff, 0xfb, 0x3b, 0x74, 0x0d, 0xd2, 0xfb,
-  0x2d, 0xbd, 0x22, 0xbb, 0xf7, 0x69, 0xbb, 0x65,
-  0x1f, 0xe5, 0x38, 0x2a, 0x7f, 0xff, 0xe6, 0xd8,
-  0x78, 0xbc, 0x40, 0xbd, 0x1e, 0xab, 0x52, 0xfa,
-  0x3f, 0xe1, 0x3a, 0x6b, 0xde, 0x7d, 0x34, 0x5d,
-  0x94, 0x56, 0x14, 0xb0, 0x8a, 0x9f, 0x69, 0x0c,
-  0xae, 0xc6, 0xdd, 0x3f, 0xf9, 0x4c, 0x05, 0x3d,
-  0xd8, 0xaf, 0xef, 0x27, 0x4f, 0xff, 0xb7, 0xdd,
-  0x53, 0x2e, 0x34, 0xb6, 0x5c, 0xff, 0xbc, 0x9d,
-  0x3f, 0xf2, 0x75, 0xee, 0xe2, 0xea, 0xde, 0x8f,
-  0x9d, 0x15, 0x45, 0x35, 0xeb, 0xd3, 0xd9, 0xac,
-  0x5e, 0x8e, 0x9c, 0xbf, 0x94, 0x3a, 0x6c, 0xe0,
-  0xe8, 0x79, 0x36, 0xd7, 0x43, 0xc2, 0xa4, 0x9a,
-  0x25, 0x5c, 0x3d, 0x3f, 0x70, 0x9d, 0xa7, 0xb8,
-  0xe9, 0xc9, 0xc2, 0x1d, 0x3f, 0x96, 0x76, 0x6a,
-  0xbe, 0xb0, 0x07, 0x90, 0xa2, 0xd9, 0xfa, 0xe2,
-  0x9f, 0x73, 0x4e, 0x4e, 0x9f, 0xc2, 0xb7, 0x72,
-  0x9f, 0xa3, 0xa3, 0x0f, 0x9b, 0x66, 0x93, 0xf2,
-  0x73, 0x9a, 0x05, 0xe3, 0xa1, 0xc7, 0xa1, 0xd2,
-  0x19, 0xff, 0xff, 0x6b, 0xbf, 0xcd, 0x5e, 0xcd,
-  0xf7, 0x5d, 0xc5, 0xc0, 0x54, 0x3d, 0x3a, 0x7f,
-  0xdb, 0xc5, 0x80, 0xaa, 0x53, 0xee, 0x67, 0x4f,
-  0xef, 0x7e, 0xb4, 0xcf, 0x13, 0xa3, 0x83, 0xf4,
-  0xd2, 0x1c, 0x94, 0x74, 0xee, 0xe7, 0x07, 0x42,
-  0x1a, 0xc7, 0xc4, 0x27, 0xe7, 0xeb, 0x99, 0xdb,
-  0xa7, 0x4f, 0x28, 0x14, 0xe4, 0xe8, 0xc3, 0xd2,
-  0xd9, 0x7c, 0x22, 0x79, 0x39, 0x0e, 0x6d, 0xa7,
-  0x8b, 0x9c, 0xfe, 0xd6, 0xde, 0xca, 0x5f, 0xa3,
-  0xa7, 0xb1, 0xf4, 0x58, 0xe9, 0xfa, 0x9e, 0xe5,
-  0x0e, 0xce, 0x9f, 0x6f, 0x91, 0xc7, 0xce, 0x8b,
-  0xa8, 0xab, 0xd9, 0xaf, 0x24, 0x57, 0x96, 0x4f,
-  0xff, 0xc2, 0xea, 0x62, 0xd4, 0x4e, 0xdd, 0xee,
-  0x6a, 0x97, 0x9d, 0x3f, 0xff, 0xb7, 0x8f, 0xba,
-  0xba, 0xa2, 0x29, 0x37, 0xc0, 0x08, 0xbd, 0xce,
-  0x9f, 0xff, 0xff, 0x5f, 0xd0, 0x03, 0xef, 0xb8,
-  0x7f, 0x90, 0x2b, 0x7a, 0x3f, 0x4c, 0xdf, 0x72,
-  0xe9, 0xd3, 0xff, 0xeb, 0xc4, 0x73, 0x55, 0xa6,
-  0xf0, 0x0a, 0x72, 0x87, 0x46, 0x23, 0x86, 0x90,
-  0x8b, 0x9f, 0xfe, 0x75, 0xc5, 0x31, 0x3a, 0xb7,
-  0x73, 0x55, 0xf3, 0xa7, 0xff, 0xdc, 0x62, 0x80,
-  0xb8, 0xd2, 0x55, 0x67, 0x78, 0xbc, 0x74, 0xff,
-  0x67, 0x5e, 0x03, 0x9f, 0xf5, 0x8e, 0x9f, 0xf5,
-  0x6f, 0xe8, 0x15, 0xbd, 0x7e, 0xf1, 0x3a, 0x7f,
-  0xf3, 0xc0, 0x56, 0x97, 0x81, 0xaa, 0xd5, 0x04,
-  0xe9, 0xff, 0xff, 0x63, 0xf5, 0xde, 0x04, 0x0a,
-  0x66, 0xab, 0x8f, 0x01, 0x9b, 0xe0, 0xe8, 0xc4,
-  0x5f, 0x6d, 0x3a, 0x1e, 0x56, 0xfe, 0xd1, 0xa5,
-  0x3e, 0x4f, 0xb5, 0x25, 0x2d, 0xd4, 0xef, 0x51,
-  0x82, 0x4f, 0xfb, 0xc6, 0x99, 0xa4, 0xee, 0xf9,
-  0x3a, 0x7f, 0xb0, 0x2f, 0xba, 0xa0, 0x6b, 0x67,
-  0x4f, 0xff, 0xf9, 0x19, 0x14, 0x02, 0xd4, 0xdf,
-  0x78, 0x00, 0x16, 0xee, 0x53, 0x0e, 0x86, 0x47,
-  0x3f, 0x4f, 0x6e, 0x0e, 0xe7, 0xb7, 0xad, 0xa1,
-  0xd3, 0xff, 0xff, 0xf6, 0x91, 0x5d, 0xdd, 0xda,
-  0x7a, 0xc0, 0x76, 0xfb, 0x80, 0x31, 0xf7, 0x65,
-  0xfd, 0xe6, 0xa7, 0x43, 0x91, 0x6f, 0xb2, 0x18,
-  0x45, 0xe4, 0x3c, 0x97, 0xbb, 0xb8, 0xd6, 0xbe,
-  0x1d, 0x33, 0xda, 0xaf, 0xf2, 0x74, 0xff, 0xd4,
-  0xd8, 0x1b, 0x1b, 0xde, 0xf1, 0x63, 0xa7, 0xed,
-  0x78, 0xf5, 0xfd, 0x9d, 0x18, 0x89, 0x4b, 0xa4,
-  0x5a, 0x45, 0x9e, 0x06, 0xff, 0xa9, 0xd3, 0xff,
-  0xf6, 0xc4, 0x0c, 0xde, 0x76, 0xed, 0x37, 0x8a,
-  0xc6, 0x3a, 0x7f, 0xff, 0xb6, 0xf0, 0xa2, 0xab,
-  0x7a, 0x00, 0x82, 0x9c, 0x51, 0x14, 0x74, 0x62,
-  0x30, 0x85, 0x6e, 0x7f, 0xff, 0xf0, 0x8e, 0xde,
-  0x02, 0x99, 0xae, 0xa2, 0xd4, 0xc7, 0x91, 0xfd,
-  0x5e, 0xc7, 0x4f, 0xff, 0xfc, 0x97, 0x68, 0x80,
-  0x77, 0x2f, 0xba, 0x03, 0xee, 0xae, 0xfa, 0x0a,
-  0x3c, 0x74, 0xf9, 0xfa, 0xef, 0x3a, 0x74, 0x62,
-  0x29, 0x2f, 0x7c, 0x8d, 0xa6, 0x85, 0x48, 0xc7,
-  0xe7, 0xfb, 0xb7, 0xad, 0xdc, 0xa7, 0xe8, 0xe9,
-  0xfe, 0xe2, 0x88, 0x1e, 0x29, 0xea, 0x3a, 0x7f,
-  0xff, 0xbc, 0x69, 0x9a, 0xde, 0x75, 0xea, 0xa6,
-  0x77, 0x8a, 0x21, 0xd3, 0xda, 0x01, 0xe1, 0x3a,
-  0x1f, 0x44, 0x47, 0xb2, 0xcf, 0xcb, 0x3e, 0xeb,
-  0xd3, 0x47, 0x4f, 0xf5, 0x3d, 0x5d, 0xca, 0x7e,
-  0x8e, 0x84, 0x3e, 0x7a, 0x98, 0x4f, 0xd9, 0xa1,
-  0x1c, 0x71, 0xd3, 0xf7, 0x72, 0x9d, 0xc6, 0x3a,
-  0x7b, 0xb9, 0x50, 0x16, 0x3d, 0x5d, 0x15, 0x47,
-  0x0a, 0xf1, 0x1a, 0x36, 0x3d, 0x95, 0x09, 0xd5,
-  0x21, 0x85, 0xa8, 0x45, 0x2e, 0x76, 0x9f, 0xfb,
-  0xbd, 0xc0, 0x07, 0x29, 0xdc, 0x58, 0xe8, 0x45,
-  0xd6, 0x4c, 0x9c, 0xa9, 0xf7, 0x79, 0xf7, 0x51,
-  0x5f, 0xc1, 0xd3, 0xfb, 0x16, 0xa6, 0x69, 0x38,
-  0x3a, 0x7f, 0xff, 0xfa, 0x99, 0xaa, 0xfa, 0xc0,
-  0x77, 0x1f, 0x76, 0x5e, 0xf7, 0x73, 0x8a, 0x6d,
-  0x63, 0xa6, 0xbe, 0xe9, 0xd0, 0x28, 0x9d, 0xd4,
-  0x21, 0x27, 0xec, 0x7b, 0xb8, 0xfd, 0x4e, 0x9f,
-  0xfc, 0x2f, 0xba, 0xb8, 0xa7, 0xd2, 0x94, 0x43,
-  0xa5, 0x53, 0xa2, 0xf3, 0xda, 0x05, 0x2a, 0x7f,
-  0x22, 0xbb, 0x94, 0xfd, 0x1d, 0x3f, 0xff, 0xed,
-  0x75, 0x39, 0x7d, 0xd5, 0xbd, 0x35, 0xdc, 0xe3,
-  0x78, 0x2b, 0x1d, 0x1b, 0x54, 0xd6, 0xb1, 0x3f,
-  0xc3, 0x43, 0xa4, 0xf5, 0x84, 0x45, 0xe4, 0x80,
-  0x98, 0xcf, 0x9d, 0xb1, 0xc7, 0xce, 0x9f, 0x65,
-  0x5e, 0xc0, 0x9d, 0x0f, 0x9e, 0x75, 0x09, 0xe7,
-  0xff, 0xdb, 0x7b, 0x1b, 0x8a, 0x6f, 0x2e, 0x81,
-  0x76, 0xf4, 0x3a, 0x7a, 0xe3, 0x59, 0x43, 0xa7,
-  0xff, 0xfe, 0xb8, 0x7d, 0xde, 0xf8, 0x1d, 0xbe,
-  0xe0, 0x0c, 0x7d, 0xd9, 0x7f, 0x79, 0xa9, 0xd0,
-  0xf2, 0x29, 0x70, 0x92, 0x7f, 0xff, 0xfc, 0x8f,
-  0xd6, 0xf4, 0x7c, 0x0a, 0x67, 0x00, 0x77, 0x2f,
-  0xba, 0x05, 0x79, 0xe7, 0x7a, 0x3a, 0x7c, 0x9d,
-  0x7f, 0xde, 0x3a, 0x7f, 0xff, 0xff, 0xf6, 0x2b,
-  0x19, 0x28, 0x8a, 0xd6, 0x56, 0xa8, 0x22, 0x9d,
-  0xc7, 0xb2, 0xfa, 0xde, 0xb7, 0x51, 0x47, 0x4f,
-  0xf7, 0x39, 0xc7, 0x72, 0x9f, 0xa3, 0xa7, 0xfe,
-  0x7d, 0x2e, 0xdc, 0x5f, 0x9d, 0x58, 0x15, 0x1d,
-  0x3f, 0xfd, 0x9a, 0xe3, 0x33, 0x9a, 0x80, 0x35,
-  0xe2, 0xa7, 0x42, 0x2b, 0x7a, 0xc2, 0x3d, 0xc6,
-  0x02, 0x24, 0x6a, 0x84, 0x85, 0x0a, 0x3e, 0x14,
-  0x7d, 0x39, 0xaa, 0x6c, 0xee, 0x00, 0x58, 0xe9,
-  0xff, 0xe7, 0xdd, 0xd4, 0x01, 0x5d, 0x4b, 0xba,
-  0xdb, 0xc7, 0x46, 0x1f, 0xa6, 0xc7, 0xe7, 0xe7,
-  0x96, 0x72, 0xf0, 0x5e, 0x3a, 0x7c, 0xad, 0xf1,
-  0x9c, 0x1d, 0x25, 0x8e, 0x99, 0x14, 0x74, 0xb4,
-  0x74, 0x09, 0xa5, 0xf1, 0x58, 0xe0, 0xf5, 0x68,
-  0x6d, 0x3d, 0xaa, 0xfb, 0xe7, 0x4c, 0xb7, 0x9d,
-  0x3f, 0xa9, 0xb1, 0x7d, 0xdd, 0x43, 0xa2, 0xe4,
-  0x26, 0x80, 0x86, 0x98, 0xfd, 0xb2, 0x35, 0x11,
-  0x5e, 0x2d, 0x3f, 0xab, 0xb7, 0xc3, 0xfd, 0xe4,
-  0xe9, 0xff, 0xf2, 0x0a, 0x36, 0x29, 0x19, 0xdb,
-  0xad, 0xea, 0x3a, 0x16, 0x44, 0x3a, 0xf9, 0xac,
-  0xee, 0xf2, 0x87, 0x4a, 0xcb, 0xc7, 0x55, 0xf0,
-  0x92, 0x82, 0x1e, 0x5d, 0xe2, 0x36, 0x0c, 0x9d,
-  0xc9, 0x69, 0x7d, 0x8f, 0xc7, 0x53, 0xb8, 0x4d,
-  0xad, 0x18, 0x18, 0xc7, 0xd6, 0xa8, 0x75, 0xd2,
-  0x7a, 0x13, 0xe1, 0xc7, 0xd9, 0xd9, 0x5a, 0xca,
-  0xa3, 0xd4, 0xe1, 0xd2, 0xe8, 0xc0, 0x17, 0xe3,
-  0x61, 0x06, 0x1c, 0x97, 0x04, 0xf3, 0xfa, 0xd8,
-  0x2d, 0xfe, 0xc6, 0x8a, 0x76, 0x7c, 0x2d, 0xfe,
-  0xc6, 0x8a, 0x8e, 0x7f, 0xde, 0xeb, 0x60, 0xb7,
-  0xfb, 0x1a, 0x26, 0x89, 0x5b, 0x0f, 0xd9, 0x46,
-  0x13, 0xfa, 0xd8, 0x2d, 0xfe, 0xc6, 0x8a, 0xbe,
-  0x7c, 0x2d, 0xfe, 0xc6, 0x8a, 0xda, 0x7f, 0x9d,
-  0x6c, 0x16, 0xff, 0x63, 0x44, 0x83, 0x2b, 0x61,
-  0xf8, 0xf9, 0x84, 0xff, 0xd6, 0xf7, 0x5b, 0x05,
-  0xbf, 0xd8, 0xd1, 0x21, 0xcf, 0x85, 0xbf, 0xd8,
-  0xd1, 0x62, 0x4f, 0xfc, 0x99, 0x5c, 0xef, 0x1b,
-  0xe5, 0x3a, 0x74, 0xee, 0xa3, 0xc7, 0x49, 0xdd,
-  0x3e, 0x0b, 0xd1, 0x27, 0x2f, 0xef, 0x93, 0xa7,
-  0xde, 0xe0, 0x68, 0x87, 0x4f, 0xd5, 0xa8, 0xec,
-  0x37, 0x33, 0xa3, 0x67, 0xb1, 0xe4, 0xf3, 0xfb,
-  0x94, 0xcd, 0x6f, 0xa1, 0x2a, 0x31, 0x38, 0x57,
-  0xe1, 0x21, 0xb2, 0x9a, 0x3c, 0x72, 0x43, 0x3f,
-  0xf5, 0x36, 0x9a, 0xa7, 0xdd, 0xce, 0xf2, 0x74,
-  0xff, 0xfe, 0xd6, 0xbd, 0xd5, 0xce, 0xa2, 0xbf,
-  0x35, 0xa4, 0x51, 0xd3, 0xff, 0xd8, 0xfb, 0xb5,
-  0x7b, 0xd6, 0xa7, 0xab, 0x75, 0x3a, 0x6a, 0x5b,
-  0x11, 0xef, 0xb4, 0x6e, 0xaf, 0x45, 0x93, 0x83,
-  0x48, 0xd2, 0x27, 0xf5, 0xb0, 0x5b, 0xfd, 0x8d,
-  0x16, 0x6c, 0xff, 0xeb, 0x2b, 0xdd, 0x6c, 0x16,
-  0xff, 0x63, 0x45, 0x01, 0x30, 0x15, 0x3a, 0x79,
-  0xbf, 0xd8, 0xd1, 0x6f, 0xcf, 0xc0, 0xeb, 0xdb,
-  0xc4, 0xe8, 0x13, 0xd6, 0xe4, 0xae, 0x7d, 0xa7,
-  0x54, 0x1a, 0x9d, 0x3f, 0x91, 0x70, 0x3a, 0xea,
-  0x72, 0x74, 0xee, 0xe3, 0x8e, 0x95, 0x9c, 0x98,
-  0x4e, 0x36, 0x89, 0x15, 0x0a, 0x74, 0x6d, 0x3f,
-  0xef, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x14, 0xa4,
-  0xff, 0x3a, 0xd8, 0x2d, 0xfe, 0xc6, 0x89, 0x3a,
-  0x56, 0x52, 0x21, 0xfd, 0x1a, 0x11, 0xdb, 0x13,
-  0x3d, 0x19, 0x07, 0x16, 0xae, 0xe7, 0x23, 0x92,
-  0x68, 0x58, 0xec, 0x9e, 0xe7, 0x0a, 0xc5, 0x89,
-  0x95, 0x2d, 0x52, 0x85, 0x3c, 0x9d, 0xd6, 0x35,
-  0xb5, 0xd0, 0xd6, 0x9f, 0x0b, 0x7f, 0xb1, 0xa2,
-  0x1f, 0x9f, 0xf7, 0xba, 0xd8, 0x2d, 0xfe, 0xc6,
-  0x89, 0x4e, 0x56, 0xc3, 0xf6, 0x51, 0x84, 0xfe,
-  0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x27, 0x9f, 0xd6,
-  0xc1, 0x6f, 0xf6, 0x34, 0x46, 0x33, 0xff, 0xac,
-  0xaf, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x13, 0xcc,
-  0x22, 0x3b, 0xde, 0x27, 0x71, 0xdd, 0x0e, 0xe7,
-  0xc2, 0xdf, 0xec, 0x68, 0x88, 0x27, 0xfd, 0xee,
-  0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x54, 0x95, 0xb0,
-  0xfd, 0x94, 0x61, 0x3f, 0xad, 0x82, 0xdf, 0xec,
-  0x68, 0x8a, 0x27, 0xf5, 0xb0, 0x5b, 0xfd, 0x8d,
-  0x11, 0x94, 0xff, 0xeb, 0x2b, 0xdd, 0x6c, 0x16,
-  0xff, 0x63, 0x44, 0xcb, 0x3f, 0xad, 0x82, 0xdf,
-  0xec, 0x68, 0xa9, 0x27, 0xf5, 0xb0, 0x5b, 0xfd,
-  0x8d, 0x15, 0xd4, 0xfe, 0xb6, 0x0b, 0x7f, 0xb1,
-  0xa2, 0xc5, 0x9f, 0xf9, 0x5e, 0xeb, 0x60, 0xb7,
-  0xfb, 0x1a, 0x27, 0xa9, 0xfe, 0x0d, 0xbd, 0x36,
-  0xbf, 0xbb, 0x83, 0xa2, 0xc8, 0x8a, 0x44, 0xc9,
-  0xfa, 0xe4, 0xf9, 0xad, 0xdf, 0x53, 0xa7, 0x85,
-  0x5a, 0x7c, 0xe9, 0xcd, 0x94, 0x2a, 0x7f, 0xfe,
-  0xa7, 0x7e, 0xee, 0xc5, 0x1c, 0xec, 0xaf, 0x3c,
-  0xa1, 0xd3, 0xff, 0xf0, 0xee, 0xe3, 0xd5, 0x64,
-  0x11, 0xdd, 0xc3, 0x5e, 0xf1, 0xd3, 0xe6, 0xdd,
-  0x01, 0x51, 0xd3, 0xff, 0xbe, 0xbd, 0xce, 0x6d,
-  0x4d, 0xb7, 0x89, 0xd3, 0xed, 0x51, 0x14, 0xc7,
-  0x4f, 0xfe, 0xe8, 0x08, 0x9d, 0x45, 0x00, 0x05,
-  0x17, 0xce, 0x9f, 0xeb, 0xfe, 0xbf, 0x4b, 0xfa,
-  0xf1, 0xd1, 0xb4, 0xf7, 0x45, 0x75, 0x4c, 0x14,
-  0x28, 0xea, 0x46, 0x89, 0xae, 0x13, 0xe7, 0x77,
-  0xf4, 0x6a, 0x85, 0xa7, 0x77, 0x75, 0x3a, 0x41,
-  0xb9, 0x4f, 0x11, 0x0a, 0x27, 0x85, 0x77, 0xa8,
-  0xe8, 0xc3, 0xce, 0xd9, 0x64, 0xff, 0xb7, 0x4f,
-  0xd2, 0x2d, 0x5d, 0xa8, 0xe9, 0xfb, 0x7d, 0xbb,
-  0xbc, 0xa9, 0xd3, 0xdd, 0xe0, 0x0b, 0xa7, 0x4f,
-  0xd9, 0x50, 0xff, 0x5e, 0x3a, 0x3c, 0xf4, 0xfa,
-  0x4d, 0x3e, 0xbe, 0xed, 0x78, 0x43, 0xa3, 0x11,
-  0x9d, 0xb8, 0x41, 0x50, 0x86, 0x7f, 0xff, 0xf5,
-  0x13, 0x62, 0x28, 0x0e, 0xb7, 0xdb, 0xdd, 0x95,
-  0xe2, 0xff, 0x17, 0x1d, 0x3e, 0x7b, 0x81, 0xd8,
-  0x4e, 0x9f, 0xb8, 0xf1, 0xe5, 0x7f, 0x0e, 0x9f,
-  0xf7, 0x76, 0xed, 0x53, 0x07, 0x75, 0x3a, 0x7f,
-  0xdf, 0x9c, 0xa7, 0x7f, 0x8c, 0xba, 0x74, 0x38,
-  0xff, 0x79, 0x3e, 0x9e, 0xbe, 0xb4, 0x51, 0xd3,
-  0xf5, 0xf5, 0xd5, 0x73, 0x47, 0x4e, 0x08, 0x42,
-  0x54, 0xff, 0xed, 0x6f, 0x55, 0xa6, 0xd7, 0xc1,
-  0x14, 0x71, 0x56, 0x2f, 0x23, 0x68, 0xa7, 0xbd,
-  0x2a, 0x1c, 0xa9, 0x83, 0x1e, 0x76, 0x52, 0x30,
-  0xad, 0xe9, 0x1e, 0xa1, 0x95, 0x35, 0xdc, 0x3a,
-  0x7c, 0x1d, 0x23, 0xe1, 0x3a, 0x7f, 0x27, 0x8d,
-  0x03, 0xfc, 0x15, 0x30, 0x42, 0x54, 0x70, 0x78,
-  0xe1, 0x31, 0x9e, 0xae, 0xb7, 0x73, 0x2a, 0xc6,
-  0x8e, 0x7f, 0xf5, 0xf5, 0xaf, 0x1d, 0x4e, 0x28,
-  0x9a, 0xa9, 0xd3, 0xfe, 0xd6, 0xc7, 0xf9, 0xb8,
-  0xd6, 0x50, 0xe8, 0x72, 0x23, 0xb6, 0x9b, 0x3e,
-  0xc7, 0xb3, 0x62, 0x74, 0xfd, 0xa4, 0x1e, 0x33,
-  0xa7, 0x4f, 0xee, 0x28, 0x9d, 0x0f, 0xbe, 0x74,
-  0xff, 0xff, 0xb6, 0xaf, 0xeb, 0xee, 0xb0, 0x73,
-  0x6b, 0xb3, 0xb9, 0xc7, 0xb8, 0xf1, 0x7a, 0xc2,
-  0x23, 0x73, 0xcb, 0x2f, 0x34, 0x9f, 0xfe, 0xcd,
-  0x57, 0x16, 0xa2, 0x2e, 0xca, 0x51, 0x0e, 0x9f,
-  0xff, 0xff, 0x6f, 0x1f, 0xae, 0xf0, 0x20, 0x63,
-  0xee, 0xae, 0xf5, 0x5d, 0xbf, 0xc7, 0x17, 0xbc,
-  0x74, 0x75, 0x1b, 0xba, 0x50, 0x9b, 0x61, 0x3a,
-  0x60, 0x79, 0x3a, 0x16, 0x35, 0xdc, 0x8b, 0x4e,
-  0x77, 0xf0, 0x74, 0xc1, 0x09, 0xd1, 0xb3, 0xd5,
-  0xa9, 0x18, 0x47, 0x27, 0x68, 0x1e, 0x4a, 0xb1,
-  0xaf, 0x9f, 0xff, 0xfd, 0xa4, 0xe2, 0x97, 0xfd,
-  0xd5, 0x7f, 0x19, 0x9d, 0xbb, 0x5a, 0xe7, 0x79,
-  0x3a, 0x1f, 0x45, 0x66, 0xcb, 0xa7, 0xfb, 0x35,
-  0x44, 0x1d, 0x63, 0x1d, 0x39, 0x05, 0x63, 0xa3,
-  0x13, 0xf5, 0xf8, 0xe0, 0x7a, 0x48, 0xbe, 0x6b,
-  0x3e, 0xee, 0x6b, 0xee, 0x0e, 0x9f, 0xfb, 0x04,
-  0x71, 0x6a, 0x65, 0x7f, 0xa7, 0x4f, 0xee, 0xa0,
-  0xde, 0xd4, 0x43, 0xa7, 0xdb, 0xbb, 0x4f, 0x71,
-  0xd3, 0xf6, 0xd1, 0x4f, 0x60, 0x4e, 0x98, 0x21,
-  0x3a, 0x18, 0xfb, 0x04, 0xa4, 0x25, 0xb3, 0xfd,
-  0x8b, 0x7a, 0xde, 0xfb, 0xaa, 0x55, 0x8d, 0x6c,
-  0xff, 0xec, 0xef, 0x39, 0x4d, 0xbf, 0x5a, 0x5f,
-  0x53, 0xa7, 0xee, 0xff, 0x3c, 0x67, 0x4e, 0x9c,
-  0x10, 0x84, 0xa9, 0xff, 0x90, 0x7b, 0x7f, 0x83,
-  0x8b, 0x22, 0x8e, 0xb1, 0x79, 0x17, 0x34, 0xff,
-  0x96, 0x86, 0x55, 0x52, 0xb4, 0x9a, 0x14, 0xa9,
-  0xde, 0x2f, 0x1e, 0x41, 0x29, 0xe7, 0x63, 0xee,
-  0x3c, 0x82, 0x53, 0xab, 0xbe, 0x0f, 0x20, 0x94,
-  0xc1, 0x09, 0xe4, 0x12, 0x86, 0x45, 0x22, 0xc5,
-  0x1a, 0x2f, 0x09, 0x54, 0xfd, 0xfd, 0xe7, 0xbf,
-  0xa2, 0xc8, 0x25, 0x63, 0x7b, 0x3c, 0xbf, 0x9f,
-  0x43, 0xa5, 0x97, 0x33, 0xed, 0xe5, 0x2a, 0x7f,
-  0x2c, 0xeb, 0xde, 0xd6, 0xde, 0x2a, 0x7f, 0x6d,
-  0xd7, 0xfd, 0x69, 0xb3, 0xa4, 0xe2, 0xa7, 0x78,
-  0xbc, 0x54, 0x15, 0x08, 0x6d, 0x58, 0x41, 0x43,
-  0x73, 0xdd, 0x4e, 0x58, 0xab, 0x1a, 0xc8, 0x44,
-  0x63, 0x64, 0x25, 0x67, 0xaf, 0xf1, 0x71, 0xd2,
-  0x51, 0xd3, 0x63, 0xb8, 0x36, 0x2b, 0x10, 0xcf,
-  0x83, 0x8b, 0x6d, 0x47, 0x4f, 0xcc, 0x8b, 0x39,
-  0x39, 0x2a, 0x5b, 0x3a, 0x7f, 0x9e, 0xbd, 0xdc,
-  0x52, 0xff, 0xe9, 0xd3, 0xf6, 0xd1, 0x4f, 0x60,
-  0x4e, 0x9f, 0x63, 0xca, 0xc5, 0x1d, 0x3a, 0xbb,
-  0x13, 0xa3, 0xa7, 0x85, 0xa2, 0x79, 0xfb, 0xbf,
-  0xcf, 0x37, 0xd4, 0xe9, 0xfb, 0x77, 0x41, 0x45,
-  0x5b, 0x84, 0xc3, 0xb0, 0x40, 0x4f, 0x6a, 0xdf,
-  0xa2, 0x28, 0xc4, 0xf4, 0xf6, 0x51, 0xd8, 0xce,
-  0xe7, 0xbb, 0x8f, 0x5e, 0x74, 0x39, 0x5e, 0xde,
-  0x16, 0x52, 0x1f, 0xdd, 0x57, 0xac, 0xa0, 0x1d,
-  0x1b, 0x4e, 0x08, 0x42, 0x54, 0xe1, 0x72, 0x15,
-  0x62, 0xf2, 0x7e, 0x79, 0x67, 0x2f, 0x05, 0xe3,
-  0xa7, 0xa9, 0xef, 0x84, 0xe9, 0xf3, 0xc3, 0xb4,
-  0x51, 0xd3, 0xff, 0xc8, 0x0e, 0xba, 0x9c, 0xfe,
-  0xb9, 0x07, 0xae, 0x3a, 0x2e, 0x42, 0x34, 0x36,
-  0x69, 0xe4, 0x5a, 0x27, 0x9c, 0xed, 0xf4, 0xe9,
-  0xfb, 0x48, 0xb7, 0x6f, 0xa9, 0xd0, 0xe3, 0xcb,
-  0xd0, 0xe4, 0xeb, 0xef, 0x5e, 0x8e, 0x9b, 0xec,
-  0xbd, 0x9b, 0x77, 0x4b, 0x92, 0x36, 0xb9, 0x30,
-  0x89, 0x23, 0xf7, 0x7a, 0x1f, 0x2e, 0x21, 0xe2,
-  0x30, 0xdc, 0x95, 0x29, 0x75, 0x85, 0x85, 0xf7,
-  0x09, 0x25, 0xa1, 0x88, 0x24, 0x6a, 0x8c, 0x0a,
-  0x92, 0xc0, 0x7d, 0x17, 0xa5, 0x35, 0x94, 0x7f,
-  0xa9, 0xd7, 0xeb, 0xe1, 0x00, 0xbf, 0x0f, 0x90,
-  0x61, 0x1b, 0x70, 0x45, 0x3f, 0xfa, 0xca, 0xf7,
-  0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x45, 0x4f, 0xeb,
-  0x60, 0xb7, 0xfb, 0x1a, 0x2e, 0x89, 0xff, 0xad,
-  0xee, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x4b, 0x9f,
-  0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x5e, 0x50, 0x8d,
-  0xe4, 0x1b, 0xc4, 0xee, 0x3b, 0xc3, 0xb6, 0x52,
-  0x58, 0xed, 0x47, 0x74, 0x86, 0x2f, 0x6b, 0x79,
-  0x6a, 0xc7, 0x5f, 0xa5, 0x2b, 0xce, 0xd7, 0x26,
-  0x4f, 0xfe, 0xb2, 0xbd, 0xd6, 0xc1, 0x6f, 0xf6,
-  0x34, 0x4b, 0x33, 0xcd, 0xfe, 0xc6, 0x88, 0xce,
-  0x7e, 0xda, 0x29, 0xec, 0x09, 0xd3, 0x75, 0xc7,
-  0x49, 0x47, 0x4f, 0xb6, 0x34, 0xfb, 0x09, 0xe9,
-  0xa8, 0xb4, 0x11, 0x69, 0xfb, 0xdd, 0xb1, 0xf1,
-  0x3a, 0x75, 0x51, 0xf3, 0xa0, 0x53, 0x0f, 0x53,
-  0xf7, 0x52, 0xf4, 0x55, 0x3f, 0xf6, 0xb6, 0x3f,
-  0xc8, 0x0f, 0xb9, 0x14, 0x74, 0xfb, 0xa8, 0xea,
-  0xf9, 0xd1, 0xb3, 0xec, 0x5c, 0x8d, 0x3f, 0xf6,
-  0x2b, 0x5b, 0x0d, 0x52, 0x9f, 0x73, 0x3a, 0x7f,
-  0xd4, 0x4d, 0xd3, 0x69, 0xd5, 0xaf, 0x3a, 0x56,
-  0xc4, 0xd5, 0x16, 0x85, 0x4f, 0x49, 0x2a, 0x8f,
+  0x48, 0x54, 0x80, 0x26, 0x94, 0x02, 0xd3, 0xfb,
+  0x58, 0x20, 0x56, 0xe8, 0x55, 0x8d, 0x34, 0xfc,
+  0xea, 0xed, 0x76, 0x2c, 0x74, 0x21, 0xf9, 0x7a,
+  0x14, 0xad, 0x89, 0x86, 0xaf, 0xc3, 0xb6, 0x7f,
+  0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x51, 0x4f, 0x85,
+  0xbf, 0xd8, 0xd1, 0x5e, 0xcf, 0xb7, 0x78, 0xd7,
+  0x3c, 0x74, 0xad, 0x87, 0xb8, 0x26, 0x13, 0xff,
+  0x5b, 0xdd, 0x6c, 0x16, 0xff, 0x63, 0x44, 0x8d,
   0x3f, 0xfa, 0xca, 0xf7, 0x5b, 0x05, 0xbf, 0xd8,
-  0xd1, 0x34, 0xcf, 0xfe, 0xb2, 0xbd, 0xd6, 0xc1,
-  0x6f, 0xf6, 0x34, 0x4e, 0x33, 0xff, 0xac, 0xaf,
-  0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x14, 0x0c, 0xf8,
-  0x5b, 0xfd, 0x8d, 0x17, 0x04, 0xc9, 0xb3, 0xa7,
-  0xf7, 0x5c, 0x9b, 0xe3, 0x14, 0x74, 0xad, 0x87,
-  0xf1, 0x43, 0x0b, 0xc5, 0x67, 0xf6, 0xec, 0x0a,
-  0x73, 0x81, 0x3a, 0x7f, 0x9d, 0x6c, 0x16, 0xff,
-  0x63, 0x44, 0x93, 0x2b, 0x50, 0xfd, 0x7c, 0xd2,
-  0x1e, 0x5d, 0x3d, 0x74, 0xab, 0x56, 0x49, 0x59,
-  0x4b, 0x95, 0x2a, 0xc3, 0x2b, 0x50, 0xaa, 0x9f,
-  0xf5, 0xdf, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0xd4,
-  0x9f, 0xf7, 0xba, 0xd8, 0x2d, 0xfe, 0xc6, 0x89,
-  0x56, 0x0e, 0x95, 0xae, 0xa2, 0x61, 0x49, 0x17,
-  0x08, 0xd3, 0xfa, 0xd8, 0x2d, 0xfe, 0xc6, 0x88,
-  0xa6, 0x7f, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x1a,
-  0x4f, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x29, 0xf9,
-  0xff, 0xd6, 0x57, 0xba, 0xd8, 0x2d, 0xfe, 0xc6,
-  0x89, 0xaa, 0x7f, 0x5b, 0x05, 0xbf, 0xd8, 0xd1,
-  0x5d, 0xcf, 0x37, 0xfb, 0x1a, 0x2b, 0xe9, 0xc1,
-  0x08, 0x4a, 0x97, 0x4a, 0xb1, 0x79, 0x02, 0x7c,
-  0xca, 0x47, 0x9c, 0xe4, 0x7c, 0xe9, 0xff, 0x65,
-  0x03, 0xfa, 0xaa, 0x63, 0xc7, 0x4f, 0xfb, 0xf6,
-  0x38, 0xf6, 0xdd, 0x9c, 0x1d, 0x2b, 0x62, 0x2e,
-  0x16, 0x21, 0xe8, 0xe5, 0x4f, 0x67, 0xff, 0x59,
-  0x5e, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x27, 0xb9,
-  0xfd, 0x6c, 0x16, 0xff, 0x63, 0x45, 0xc3, 0x3f,
-  0xf5, 0xbd, 0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x49,
-  0xf0, 0x8a, 0xec, 0xde, 0x3b, 0x71, 0xdd, 0xd3,
-  0xb6, 0x3b, 0x59, 0x48, 0x63, 0x59, 0xa2, 0x1d,
-  0x54, 0x97, 0x1d, 0xcf, 0xeb, 0x60, 0xb7, 0xfb,
-  0x1a, 0x22, 0xa9, 0xfd, 0x6c, 0x16, 0xff, 0x63,
-  0x45, 0x33, 0x3f, 0xfa, 0xca, 0xf7, 0x5b, 0x05,
-  0xbf, 0xd8, 0xd1, 0x33, 0xcf, 0xfe, 0xb2, 0xbd,
-  0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x51, 0xb0, 0xf2,
-  0x63, 0x5c, 0x1d, 0xdd, 0x3b, 0xd2, 0x94, 0xff,
-  0xd6, 0xf7, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x1d,
-  0x4f, 0xdb, 0xce, 0xf1, 0x8f, 0x1d, 0x3e, 0x16,
-  0xff, 0x63, 0x45, 0x35, 0x3f, 0x6d, 0x14, 0xf6,
-  0x04, 0xe9, 0xff, 0xec, 0xd5, 0x31, 0xc3, 0xfd,
-  0xd5, 0x3d, 0xc7, 0x4c, 0x9c, 0x9d, 0x3f, 0xd5,
-  0xf7, 0xd1, 0xb6, 0xd6, 0x14, 0x48, 0x74, 0xb4,
-  0x14, 0xd9, 0x5b, 0x84, 0xd2, 0xf0, 0xbb, 0x50,
-  0xc0, 0x9f, 0x0b, 0x7f, 0xb1, 0xa2, 0xaa, 0x9f,
-  0xf7, 0xba, 0xd8, 0x2d, 0xfe, 0xc6, 0x89, 0xb6,
-  0x56, 0xc3, 0xf6, 0x51, 0x84, 0xfe, 0xb6, 0x0b,
-  0x7f, 0xb1, 0xa2, 0xbf, 0x9f, 0xd6, 0xc1, 0x6f,
-  0xf6, 0x34, 0x58, 0xd3, 0xe1, 0x6f, 0xf6, 0x34,
-  0x5a, 0xb3, 0xfe, 0xf7, 0x5b, 0x05, 0xbf, 0xd8,
-  0xd1, 0x41, 0x4a, 0xd8, 0x7e, 0xca, 0x30, 0x9f,
-  0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x5c, 0x53, 0xfa,
-  0xd8, 0x2d, 0xfe, 0xc6, 0x8b, 0xa6, 0x7f, 0xfd,
-  0xdf, 0xb6, 0x9d, 0x82, 0x3e, 0xe7, 0xb0, 0x27,
-  0x4f, 0xd7, 0x2f, 0x72, 0x9f, 0xa3, 0xa7, 0x9b,
-  0xfd, 0x8d, 0x12, 0x64, 0xff, 0x0e, 0x3f, 0xad,
-  0x7b, 0xaa, 0x74, 0x09, 0xf1, 0xa8, 0xae, 0x7e,
-  0xe3, 0x9b, 0x96, 0xbc, 0xaf, 0x9d, 0x3e, 0xcd,
-  0x6d, 0x5e, 0x74, 0xff, 0xfb, 0xd8, 0x52, 0x9d,
-  0xcd, 0x65, 0x82, 0x10, 0x95, 0x0e, 0x3f, 0x8d,
-  0x13, 0x4f, 0xfe, 0xbf, 0xbf, 0xa4, 0x1a, 0xd1,
-  0x3b, 0xa3, 0xa7, 0x04, 0x21, 0x2a, 0x7e, 0x1f,
-  0x79, 0x5b, 0xa9, 0x56, 0x2f, 0x27, 0xd8, 0xa1,
-  0xcb, 0x99, 0xd3, 0xfe, 0x52, 0x35, 0x3b, 0x7e,
-  0x92, 0xa7, 0x4f, 0xf6, 0x7f, 0x20, 0x67, 0x1e,
-  0xe3, 0xa7, 0xff, 0x7b, 0xd4, 0xda, 0x77, 0x16,
-  0xd8, 0xec, 0xe8, 0xc4, 0x60, 0xe8, 0xf8, 0x27,
-  0x33, 0xf5, 0xcf, 0xb9, 0x4f, 0xd1, 0xd3, 0xda,
-  0x7b, 0x38, 0x3a, 0x7f, 0xb7, 0x74, 0x11, 0xe5,
-  0x5b, 0xa9, 0xd0, 0xb1, 0xf0, 0x2f, 0x91, 0xce,
-  0x08, 0x42, 0x74, 0xff, 0xfb, 0x15, 0xae, 0xa7,
-  0x39, 0xc5, 0x71, 0x48, 0xc5, 0x58, 0xbc, 0x8c,
-  0x4c, 0xd7, 0x70, 0x90, 0xa2, 0x14, 0xfe, 0x11,
-  0xf1, 0xea, 0x38, 0xe9, 0x9d, 0x65, 0xe2, 0xe6,
-  0xde, 0x42, 0x52, 0xe9, 0x0b, 0xf0, 0xb1, 0x58,
-  0x8b, 0xd9, 0x7a, 0x79, 0x58, 0x75, 0x6a, 0x36,
-  0x40, 0x4d, 0x67, 0xd8, 0xa1, 0xcb, 0x99, 0xd3,
-  0xff, 0x65, 0x3a, 0x8f, 0x03, 0x4a, 0x7d, 0xcc,
-  0xe9, 0xfb, 0xda, 0xc1, 0x08, 0x4e, 0x95, 0x99,
-  0x7a, 0x0b, 0xe7, 0x4b, 0xbb, 0x0b, 0x6a, 0x94,
-  0xae, 0x49, 0x87, 0x32, 0xb6, 0xf8, 0x8e, 0x5d,
-  0xf8, 0x59, 0x09, 0x3a, 0x8e, 0xf9, 0x85, 0x8d,
-  0x49, 0xf4, 0x77, 0x7c, 0xf5, 0xec, 0xfe, 0xb6,
-  0x0b, 0x7f, 0xb1, 0xa2, 0x35, 0x9f, 0x0b, 0x7f,
-  0xb1, 0xa2, 0xa5, 0x9b, 0xd8, 0xd1, 0x0d, 0x4a,
-  0xd8, 0x7a, 0x3e, 0x61, 0x3f, 0xf5, 0xbd, 0xd6,
-  0xc1, 0x6f, 0xf6, 0x34, 0x47, 0xd3, 0xfa, 0xd8,
-  0x2d, 0xfe, 0xc6, 0x8b, 0x1e, 0x7e, 0xb9, 0x7b,
-  0x94, 0xfd, 0x1d, 0x3f, 0xdd, 0xfe, 0x6b, 0xfa,
-  0xd7, 0x9d, 0x3d, 0xca, 0xb6, 0x27, 0x4f, 0xff,
-  0xf2, 0x0f, 0x73, 0x8c, 0xa5, 0x36, 0xd4, 0xde,
-  0xab, 0xef, 0x9d, 0x1b, 0x44, 0x45, 0x08, 0xa7,
-  0xc2, 0xdf, 0xec, 0x68, 0xb4, 0x27, 0xe5, 0xc0,
-  0xeb, 0xa9, 0xc9, 0xd3, 0xe4, 0xd6, 0x51, 0x0e,
-  0x9f, 0xfe, 0xcd, 0x57, 0x16, 0xa2, 0x2e, 0xca,
-  0x51, 0x0e, 0x87, 0x8f, 0xd7, 0xa4, 0xb0, 0x88,
-  0xc9, 0xc8, 0x53, 0x4f, 0xf7, 0x73, 0x35, 0x4f,
-  0xed, 0xd3, 0xa7, 0xf6, 0x51, 0x6d, 0xd3, 0x6a,
-  0x3a, 0x7f, 0x3b, 0x06, 0xbd, 0x47, 0x8e, 0x9f,
-  0xec, 0xc0, 0xe3, 0x36, 0x04, 0xe8, 0xc4, 0x4d,
-  0x3e, 0x69, 0x53, 0x29, 0xec, 0xa7, 0xe8, 0xe9,
-  0xfd, 0x77, 0x7d, 0xbd, 0xd9, 0x53, 0xa5, 0x65,
-  0xe2, 0xb8, 0xc4, 0x31, 0xe2, 0x18, 0x18, 0x47,
-  0x48, 0x7c, 0xd4, 0x9b, 0x50, 0xd3, 0x5f, 0x30,
-  0x04, 0x82, 0x7e, 0xb8, 0xdf, 0x1d, 0x45, 0x8e,
-  0x9e, 0xca, 0x7e, 0x8e, 0x95, 0xcb, 0x87, 0xa5,
-  0xd3, 0x29, 0xf0, 0xb7, 0xfb, 0x1a, 0x2d, 0x69,
-  0xff, 0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68, 0xa0,
-  0xe5, 0x65, 0xe2, 0x28, 0xb0, 0xb1, 0x46, 0x13,
-  0xff, 0xac, 0xaf, 0x75, 0xb0, 0x5b, 0xfd, 0x8d,
-  0x14, 0x5c, 0xfe, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2,
-  0xea, 0x87, 0x2f, 0x8d, 0xb4, 0x23, 0x36, 0x4c,
-  0xa4, 0xca, 0x4b, 0xc7, 0xe6, 0x39, 0x0a, 0x9c,
-  0xe9, 0x4a, 0x7c, 0x2d, 0xfe, 0xc6, 0x88, 0x86,
-  0x75, 0x33, 0x83, 0xa5, 0x6c, 0x3c, 0xc7, 0xcc,
-  0x27, 0xf5, 0xb0, 0x5b, 0xfd, 0x8d, 0x11, 0xb4,
-  0xfe, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x9b, 0x9f,
-  0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x54, 0x13, 0xfa,
-  0xd8, 0x2d, 0xfe, 0xc6, 0x8a, 0x9a, 0x7c, 0x2d,
-  0xfe, 0xc6, 0x8a, 0xc2, 0x7d, 0xb0, 0xf1, 0x78,
-  0x9d, 0x3f, 0xce, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2,
-  0x3f, 0x9d, 0x88, 0xf1, 0xd2, 0xb6, 0x22, 0xd5,
-  0x8c, 0x3c, 0xa7, 0xa8, 0x33, 0xff, 0xac, 0xaf,
-  0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x13, 0x7c, 0xff,
-  0xca, 0xf7, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x3f,
-  0x4f, 0xcb, 0xde, 0xe4, 0x5c, 0xab, 0xf8, 0xf9,
-  0xd3, 0xff, 0xc8, 0x88, 0x88, 0x88, 0x88, 0x8f,
-  0xd4, 0xe9, 0xf0, 0xed, 0xef, 0x51, 0x53, 0x04,
-  0x25, 0x46, 0x1b, 0xd0, 0x93, 0xca, 0xf2, 0xac,
-  0x68, 0x21, 0x11, 0x8f, 0x58, 0x53, 0x4f, 0xc3,
-  0xed, 0x4d, 0x89, 0xd3, 0xcf, 0x2b, 0x6e, 0x3a,
-  0x7f, 0x51, 0x15, 0x6e, 0x79, 0x43, 0xa4, 0x28,
-  0x7a, 0xfb, 0x23, 0x9d, 0xcd, 0x70, 0xe9, 0xea,
-  0xeb, 0x6b, 0x1d, 0x08, 0x98, 0x6e, 0xc9, 0xc6,
-  0x10, 0x3d, 0x26, 0xd0, 0xe4, 0xf7, 0xac, 0x0a,
-  0x8e, 0x9b, 0xfa, 0x74, 0x09, 0xb8, 0x51, 0x1c,
-  0xe0, 0x84, 0x27, 0x4f, 0x3d, 0xdd, 0xa1, 0x56,
-  0x2f, 0x27, 0x9f, 0xd6, 0xd8, 0xe8, 0x44, 0x47,
-  0xd0, 0xf2, 0xf3, 0x19, 0xff, 0x9e, 0xbf, 0x9c,
-  0xed, 0xeb, 0x26, 0xbc, 0xe9, 0xe4, 0xd5, 0x58,
-  0xd1, 0x07, 0x40, 0x9f, 0xae, 0x92, 0x26, 0x1e,
-  0x0e, 0x98, 0x21, 0x3a, 0x1c, 0x6b, 0x02, 0x2d,
-  0x3d, 0x54, 0xda, 0xe2, 0xac, 0x68, 0x67, 0xd5,
-  0x07, 0x8e, 0x6a, 0x74, 0x6c, 0xf7, 0x81, 0x33,
-  0x9c, 0x10, 0x84, 0xa8, 0x2a, 0xc5, 0xe4, 0xf6,
-  0xc3, 0xb5, 0x8a, 0x86, 0x37, 0x9b, 0x19, 0x8d,
-  0xa6, 0xcf, 0x48, 0x66, 0x75, 0xee, 0x7b, 0x8f,
-  0xef, 0x27, 0x4f, 0xfc, 0x9d, 0xe7, 0xa8, 0xfa,
-  0xc9, 0xde, 0x4e, 0x8e, 0x4f, 0xaa, 0xa4, 0x73,
-  0xf2, 0xc9, 0x83, 0x4d, 0x9d, 0x3f, 0x6b, 0x16,
-  0xea, 0x28, 0xf1, 0x01, 0x4f, 0xbf, 0xbc, 0x51,
-  0x0d, 0x10, 0x15, 0x8d, 0xd4, 0xf9, 0x39, 0xdb,
-  0xf5, 0x3a, 0x7f, 0x0a, 0xd5, 0xdf, 0x75, 0xb3,
-  0xa7, 0x9f, 0xe4, 0x50, 0xa9, 0x82, 0x12, 0xa1,
-  0x0d, 0xc0, 0x48, 0xa7, 0xef, 0x17, 0x3b, 0xbb,
-  0x2a, 0xc6, 0x82, 0x11, 0x3b, 0xec, 0x23, 0xdb,
-  0x37, 0x51, 0x34, 0x53, 0x7c, 0x23, 0x27, 0xd7,
-  0xea, 0xff, 0x04, 0xd1, 0x03, 0xcf, 0xfa, 0x97,
-  0xbc, 0x80, 0x26, 0x93, 0x83, 0xa7, 0x78, 0xbc,
-  0x74, 0xc1, 0x09, 0xd3, 0xf8, 0x77, 0x8b, 0x81,
-  0x75, 0x98, 0xd8, 0x84, 0x6e, 0x49, 0xc2, 0x2f,
-  0x45, 0xca, 0x7f, 0xf6, 0x29, 0x5e, 0xec, 0x16,
-  0xff, 0x63, 0x44, 0x31, 0x14, 0x3f, 0x9e, 0x94,
-  0x4f, 0xd8, 0x2d, 0xfe, 0xc6, 0x88, 0x2a, 0x7b,
-  0x55, 0x4e, 0x4a, 0x9d, 0xe2, 0xf1, 0x53, 0xd7,
-  0xf7, 0xee, 0x95, 0x3f, 0xb6, 0xf6, 0x6a, 0xa9,
-  0xc9, 0x50, 0x54, 0xfd, 0x8c, 0x94, 0x45, 0x15,
-  0x30, 0x42, 0x54, 0xfd, 0xd4, 0xeb, 0xdb, 0x12,
-  0xa3, 0x13, 0x0c, 0x62, 0x25, 0x0d, 0xd0, 0x93,
-  0x93, 0x4e, 0x85, 0x04, 0xa8, 0x11, 0x69, 0xb6,
-  0x25, 0x58, 0xfc, 0xa5, 0xee, 0x4f, 0x66, 0x91,
-  0xd9, 0xcf, 0xf9, 0x1d, 0xfd, 0xca, 0x8a, 0x54,
-  0xe9, 0xff, 0x26, 0xa8, 0x8b, 0xb8, 0x4e, 0x50,
-  0xe9, 0xff, 0xf9, 0x6f, 0xf7, 0x7d, 0x00, 0xc7,
-  0xaf, 0xd5, 0xfe, 0x09, 0xa2, 0xfb, 0x9f, 0x6f,
-  0x5d, 0xc7, 0x1d, 0x3f, 0xee, 0xed, 0xda, 0xa6,
-  0x0e, 0xea, 0x74, 0xfe, 0xd7, 0x20, 0xf5, 0xd4,
-  0xc3, 0xc4, 0x03, 0x3b, 0xc5, 0xc7, 0x88, 0x06,
-  0x30, 0xfa, 0x6f, 0x42, 0x9b, 0xdc, 0x78, 0x80,
-  0x67, 0xbf, 0xaf, 0xb8, 0xf1, 0x00, 0xcf, 0xed,
-  0xb5, 0x33, 0x9e, 0x50, 0xf1, 0x00, 0xce, 0xdf,
-  0x78, 0x3c, 0x40, 0x31, 0xc2, 0x2e, 0xd4, 0x45,
-  0x42, 0xf5, 0xc8, 0x13, 0x85, 0x34, 0x78, 0x80,
-  0x60, 0xf1, 0x00, 0xcc, 0x8a, 0x3c, 0x40, 0x31,
-  0xc1, 0xb9, 0xd8, 0xbc, 0xf6, 0xd5, 0xc2, 0x1e,
-  0x20, 0x19, 0xda, 0xf6, 0x3c, 0x40, 0x33, 0xfe,
-  0xef, 0xba, 0xd4, 0xdb, 0x78, 0x9e, 0x20, 0x19,
-  0xbf, 0x83, 0xc4, 0x03, 0x3f, 0xbb, 0xe1, 0xad,
-  0x53, 0x93, 0xc4, 0x03, 0x3e, 0xdd, 0xdf, 0xef,
-  0x27, 0x88, 0x06, 0x6d, 0xd4, 0xf1, 0x00, 0xc0,
-  0x9e, 0xd6, 0x8d, 0xe7, 0xda, 0xea, 0x3e, 0xe3,
-  0x44, 0x03, 0x37, 0x28, 0x78, 0x80, 0x6c, 0x6d,
-  0x67, 0xdb, 0x45, 0x7f, 0x07, 0x88, 0x06, 0x7a,
-  0xff, 0xeb, 0x1e, 0x20, 0x19, 0xc8, 0x2c, 0x78,
-  0x80, 0x67, 0xfd, 0x8f, 0xd7, 0x84, 0xce, 0xf3,
-  0x53, 0xc4, 0x03, 0x3e, 0xbf, 0xdc, 0xe4, 0x3c,
-  0x40, 0x31, 0x88, 0x81, 0xa2, 0x6c, 0xc3, 0xc9,
-  0xe2, 0x01, 0x87, 0x2a, 0x94, 0xe0, 0x8f, 0x21,
-  0x35, 0xb5, 0x6a, 0x19, 0xf2, 0x69, 0x52, 0xed,
-  0x42, 0x9e, 0xf2, 0x29, 0xf6, 0x6a, 0xbe, 0xf9,
-  0xe2, 0x01, 0x9f, 0xdc, 0x23, 0x2c, 0x29, 0xa3,
-  0xc4, 0x03, 0xc1, 0xb4, 0x9c, 0x28, 0x13, 0xc4,
-  0x03, 0x0c, 0x7e, 0xe2, 0xa1, 0x3d, 0xbe, 0xba,
-  0xa7, 0x88, 0x06, 0x7e, 0xf5, 0x9d, 0x8f, 0xb8,
-  0xf1, 0x00, 0xc6, 0x22, 0x2b, 0x92, 0x0b, 0xcb,
-  0xe7, 0xff, 0x7b, 0xdc, 0x51, 0x2b, 0x6a, 0xde,
-  0x3c, 0x9e, 0x20, 0x19, 0x87, 0x93, 0xc4, 0x03,
-  0x3e, 0xfd, 0x57, 0x6f, 0x9e, 0x20, 0x19, 0xfb,
-  0x7d, 0xbd, 0xd9, 0x53, 0xc4, 0x03, 0x08, 0x89,
-  0x3e, 0x91, 0xe8, 0xd6, 0x38, 0x5f, 0xe0, 0xc8,
-  0x6e, 0xac, 0x80, 0x2c, 0x14, 0x22, 0xf2, 0xfe,
-  0x49, 0xeb, 0x2b, 0x77, 0x51, 0xe0, 0xaf, 0x98,
-  0x83, 0x0e, 0xd9, 0xdf, 0xec, 0x68, 0x80, 0x6c,
-  0x8b, 0x69, 0xeb, 0xb7, 0x25, 0xc2, 0x8e, 0x9b,
-  0x94, 0x2a, 0x57, 0x4a, 0x9d, 0x44, 0x78, 0xe9,
-  0x82, 0x12, 0xa3, 0x67, 0xb5, 0x73, 0x16, 0x58,
-  0x48, 0x23, 0x93, 0x95, 0xba, 0x95, 0x63, 0xc1,
-  0x9e, 0xd5, 0x6e, 0x2f, 0x3a, 0x1e, 0x65, 0x5b,
-  0x38, 0x9d, 0xa9, 0x27, 0xbb, 0x38, 0xe6, 0x18,
-  0xe0, 0x96, 0xcf, 0xc2, 0xb3, 0x90, 0x5e, 0x3a,
-  0x7f, 0xce, 0xa8, 0x1d, 0xc5, 0x20, 0xdd, 0x3a,
-  0x7e, 0x04, 0x23, 0xbc, 0xa1, 0x53, 0xcb, 0x53,
-  0xd6, 0x3a, 0x7d, 0x8b, 0x39, 0x1f, 0x3a, 0x7b,
-  0x3a, 0x8e, 0x2a, 0x04, 0xfa, 0xfa, 0x47, 0x70,
-  0x51, 0x08, 0x99, 0xb6, 0x16, 0xd1, 0x03, 0xe1,
-  0x31, 0x3d, 0xbe, 0xea, 0xa7, 0x4e, 0xbd, 0x7a,
-  0xa9, 0xd3, 0xff, 0x6a, 0xb9, 0xc2, 0x3f, 0x5c,
-  0x7f, 0x47, 0x42, 0x1f, 0x47, 0x91, 0x4f, 0xbd,
-  0x77, 0x1c, 0x21, 0xd3, 0x56, 0xa7, 0x4e, 0x08,
-  0x42, 0x74, 0xdc, 0xf9, 0x56, 0x2f, 0x20, 0x4f,
-  0x5e, 0xa6, 0x53, 0xbf, 0x9c, 0x2a, 0x1c, 0x8b,
-  0xd5, 0x42, 0x05, 0x7c, 0x86, 0x7f, 0x6b, 0xb8,
-  0xff, 0x20, 0xb8, 0xe9, 0xfe, 0xee, 0x2e, 0xcb,
-  0x04, 0x21, 0x2a, 0x72, 0xbf, 0x47, 0x45, 0x0f,
-  0x55, 0x71, 0xd4, 0x22, 0x39, 0xf6, 0x71, 0xf0,
-  0x8b, 0x9a, 0x9e, 0x74, 0xcb, 0x54, 0xe9, 0xfa,
-  0xd8, 0xbb, 0x7d, 0xe3, 0x0d, 0x60, 0x22, 0xb3,
-  0xdc, 0x65, 0x3c, 0xe9, 0xff, 0x93, 0x3a, 0xea,
-  0x67, 0x7a, 0x81, 0x3a, 0x5b, 0x14, 0x55, 0x75,
-  0x1f, 0x44, 0x30, 0xf3, 0x69, 0x42, 0xe8, 0xdb,
-  0x78, 0x8f, 0xee, 0xe9, 0x7b, 0x1d, 0xed, 0x00,
-  0x69, 0x64, 0x54, 0x8e, 0x87, 0x94, 0x0e, 0xc2,
-  0x2b, 0x51, 0xe2, 0x2e, 0x8c, 0x26, 0x7e, 0xef,
-  0x39, 0xc7, 0xb8, 0xe9, 0xf0, 0x2b, 0x39, 0x2e,
-  0x65, 0x46, 0x1e, 0xd8, 0x25, 0xd3, 0xff, 0x86,
-  0xef, 0x6f, 0xf0, 0x72, 0xbb, 0x4e, 0x9d, 0x20,
-  0x4d, 0x10, 0x2c, 0xb4, 0x6a, 0x05, 0x25, 0xbd,
-  0x1b, 0xb0, 0x8f, 0x4f, 0xfb, 0x6b, 0xf4, 0xd8,
-  0x36, 0xe7, 0x94, 0x2a, 0x7f, 0xf6, 0xab, 0xef,
-  0x80, 0xa4, 0xce, 0xe9, 0x7c, 0xe8, 0x44, 0x49,
-  0xed, 0x16, 0x73, 0xdd, 0x71, 0xd0, 0x89, 0xc0,
-  0x2a, 0x10, 0xf4, 0x85, 0xd5, 0xe4, 0x53, 0xf9,
-  0xcb, 0x67, 0x7e, 0x98, 0x74, 0xff, 0xe1, 0x6e,
-  0xe2, 0xee, 0xe2, 0x0a, 0x54, 0xe9, 0xfd, 0xeb,
-  0x53, 0x15, 0x95, 0x3a, 0x30, 0xfe, 0x57, 0x23,
-  0xcf, 0xff, 0xc8, 0x1a, 0xe9, 0xf6, 0xdd, 0x00,
-  0xb8, 0xca, 0x6d, 0x47, 0x46, 0xd1, 0x07, 0xa2,
-  0x39, 0xdc, 0x78, 0x9d, 0x3e, 0xe7, 0xfb, 0x97,
-  0x07, 0x42, 0x1e, 0x2d, 0xe3, 0x73, 0xc8, 0xa7,
-  0xd6, 0x3a, 0x11, 0x3d, 0xb7, 0x46, 0x5d, 0x56,
-  0x8d, 0x11, 0x4f, 0x73, 0xef, 0xd4, 0xe9, 0x82,
-  0x13, 0xa2, 0xa6, 0xe4, 0x24, 0x73, 0xf5, 0x77,
-  0x4f, 0xca, 0x15, 0x63, 0x43, 0x38, 0x21, 0x09,
-  0x53, 0xce, 0xd6, 0x31, 0x56, 0x2f, 0x27, 0xd9,
-  0xc6, 0xf9, 0xa9, 0xd2, 0xf1, 0x3d, 0x8e, 0x97,
-  0xcf, 0xdd, 0x7e, 0xab, 0x66, 0x8e, 0x9f, 0x3d,
-  0x73, 0xde, 0x3e, 0x74, 0xff, 0xb1, 0xb8, 0xc1,
-  0x0f, 0xd1, 0x63, 0xa6, 0x73, 0xc5, 0x43, 0xe7,
-  0xa9, 0xd3, 0xd8, 0x14, 0x52, 0x7c, 0x20, 0x61,
-  0x13, 0x1f, 0xc2, 0x6f, 0x86, 0x9c, 0xff, 0xae,
-  0xa3, 0xfd, 0x4a, 0x52, 0xf6, 0x3a, 0x7e, 0xef,
-  0xdd, 0xa7, 0xb8, 0xe9, 0xc1, 0x08, 0x4a, 0x9c,
-  0x0a, 0x72, 0x55, 0x8b, 0xc9, 0xfe, 0xef, 0xf2,
-  0x03, 0x93, 0x97, 0xce, 0x8e, 0x11, 0xe6, 0xa4,
-  0x1e, 0x52, 0xb4, 0x59, 0x38, 0x21, 0x09, 0x62,
-  0x10, 0x9f, 0x0b, 0x7f, 0xb1, 0x62, 0x10, 0xb1,
-  0xa9, 0x9c, 0x10, 0x84, 0xb1, 0x07, 0xc1, 0x62,
-  0x0f, 0xb1, 0xa9, 0x99, 0x15, 0x88, 0x90, 0x66,
-  0x99, 0xf6, 0x93, 0x48, 0xa3, 0xa7, 0xbb, 0xb4,
-  0xba, 0x74, 0xe0, 0x53, 0x93, 0xa1, 0xe3, 0xc0,
-  0x51, 0x1c, 0xf9, 0x92, 0x88, 0xa2, 0xa7, 0xdd,
-  0xfe, 0xf7, 0x0a, 0x9b, 0x18, 0xa9, 0x82, 0x12,
-  0xa3, 0x0f, 0xd6, 0xa4, 0xba, 0x26, 0x08, 0xa4,
-  0xfe, 0xe8, 0x29, 0xcd, 0x32, 0xe0, 0xab, 0x1b,
-  0xb8, 0x44, 0xe0, 0x36, 0xcd, 0xf0, 0xd3, 0x9f,
-  0xfd, 0x44, 0xe6, 0xb9, 0x9c, 0x7f, 0x7e, 0xe9,
-  0xd3, 0xfa, 0xa0, 0xaa, 0xa1, 0xf7, 0xce, 0x84,
-  0x56, 0xb1, 0xb8, 0x7c, 0x0c, 0x75, 0x9e, 0x69,
-  0x54, 0xb9, 0xc1, 0x08, 0x4a, 0x9f, 0x3b, 0x9f,
-  0xef, 0x05, 0x58, 0xbc, 0x9f, 0xfe, 0xeb, 0xe0,
-  0x3f, 0xca, 0x75, 0xbd, 0xee, 0xf9, 0xd3, 0xff,
-  0xe7, 0x62, 0x5b, 0x8e, 0xa5, 0xed, 0x97, 0x76,
-  0x27, 0x4f, 0x6f, 0x8c, 0x51, 0xd0, 0x89, 0x81,
-  0xb8, 0xe3, 0xd4, 0xef, 0x56, 0x9f, 0xf5, 0x6a,
-  0x83, 0xa4, 0xb7, 0x1b, 0x3a, 0x7f, 0xdd, 0xf5,
-  0xa9, 0xe2, 0x3b, 0xe0, 0xe8, 0xd9, 0xfe, 0x28,
-  0xfa, 0x7e, 0xf1, 0xe3, 0x33, 0xa7, 0x4f, 0xff,
-  0x66, 0xab, 0x8b, 0x51, 0x17, 0x65, 0x28, 0x87,
-  0x4f, 0xed, 0x2f, 0x75, 0xba, 0xbd, 0x9e, 0xbc,
-  0xe8, 0xe1, 0x17, 0xdd, 0x2b, 0xd2, 0x84, 0xff,
-  0xfe, 0xee, 0xb2, 0x9b, 0x4d, 0x6f, 0x94, 0x75,
-  0x82, 0x10, 0x95, 0x3d, 0xc6, 0x65, 0xd2, 0xa7,
-  0x3b, 0xb7, 0x9a, 0x21, 0x99, 0xc1, 0x08, 0x4a,
-  0x9d, 0x9d, 0x62, 0xac, 0x5e, 0x4f, 0xfb, 0x1e,
-  0xce, 0x3d, 0xdd, 0x47, 0x8e, 0x8e, 0x4f, 0xa3,
-  0xa5, 0x30, 0x89, 0xab, 0x3c, 0xc4, 0xf9, 0x18,
-  0xc2, 0xba, 0x7b, 0x7a, 0xda, 0x1d, 0x3f, 0xaf,
-  0xc1, 0xe7, 0x9d, 0xf4, 0xe9, 0xff, 0xf2, 0x3b,
-  0x7c, 0x50, 0x1a, 0xe0, 0xb7, 0xfb, 0x1a, 0x20,
-  0xc8, 0xa2, 0x25, 0x74, 0x6b, 0x3f, 0x97, 0xf2,
-  0xab, 0xf8, 0x28, 0x74, 0x39, 0x30, 0xfd, 0xc2,
-  0xdb, 0x44, 0x73, 0xff, 0xc9, 0xd7, 0x80, 0x5b,
-  0x7d, 0xce, 0x33, 0xb7, 0x4e, 0x9c, 0x82, 0xb1,
-  0xd0, 0x8b, 0x8b, 0xf9, 0x0e, 0x0d, 0xc7, 0x0f,
-  0xf1, 0xa9, 0x5e, 0x6c, 0xbe, 0xab, 0x3f, 0xb5,
-  0xb5, 0xdb, 0xd3, 0x90, 0xa9, 0x28, 0xe9, 0xfd,
-  0x5c, 0xed, 0xd1, 0x4b, 0x6c, 0xf1, 0x41, 0x35,
-  0x9e, 0x1b, 0xdf, 0x71, 0xd3, 0xfb, 0xae, 0xee,
-  0x29, 0x18, 0xe9, 0xca, 0xe3, 0x0e, 0x84, 0x3f,
-  0x0c, 0x23, 0xf3, 0x19, 0xff, 0x5f, 0xaa, 0x82,
-  0x3c, 0xab, 0x75, 0x3a, 0x7f, 0xe4, 0xef, 0xd1,
-  0x39, 0xb0, 0xd6, 0xa5, 0x47, 0x08, 0x85, 0x52,
-  0x14, 0xfa, 0x9b, 0xdb, 0xf5, 0x3a, 0x6e, 0x50,
-  0xe9, 0xf8, 0x7f, 0xa0, 0xa7, 0x27, 0x4d, 0xe2,
-  0x74, 0xb6, 0x73, 0x16, 0x92, 0x63, 0xa4, 0xa3,
-  0xa7, 0x62, 0xfd, 0xb6, 0x89, 0x41, 0x16, 0xa2,
-  0x0f, 0x8f, 0x02, 0x1f, 0x3f, 0xfe, 0xbd, 0x00,
-  0xf1, 0x1f, 0xe5, 0x2c, 0x10, 0x84, 0xe8, 0x72,
-  0xb0, 0x0e, 0x21, 0x79, 0xb8, 0x58, 0xac, 0x49,
-  0xd8, 0x5e, 0xe9, 0x76, 0x7f, 0x27, 0x75, 0xfd,
-  0xbf, 0x0e, 0x9f, 0xc2, 0xee, 0xed, 0xd4, 0xc3,
-  0xa7, 0xd9, 0xce, 0x62, 0xc7, 0x4f, 0xd5, 0xc5,
-  0xdd, 0x47, 0xce, 0x92, 0x62, 0x22, 0x3a, 0x65,
-  0xa2, 0x79, 0xeb, 0xfc, 0x5c, 0x74, 0xf2, 0x5e,
-  0xbd, 0x54, 0xa9, 0xf3, 0xac, 0x10, 0x84, 0xe8,
-  0xe9, 0xe7, 0xde, 0x4f, 0x1c, 0x22, 0x4f, 0x1c,
-  0x21, 0x49, 0xd2, 0x73, 0x0b, 0xab, 0xe1, 0x8f,
-  0x3f, 0x0d, 0xfc, 0xe7, 0x58, 0xe9, 0xee, 0x38,
-  0x45, 0xc7, 0x4f, 0xff, 0x92, 0x88, 0xa6, 0x4d,
-  0x60, 0xb7, 0xfb, 0x1a, 0x2f, 0x89, 0xfc, 0x1f,
-  0xd5, 0x53, 0x1e, 0x3a, 0x7f, 0xfe, 0xcd, 0x02,
-  0xe4, 0x5d, 0xbe, 0xf2, 0x3b, 0x45, 0x61, 0x53,
-  0x6b, 0x0e, 0x9f, 0x0e, 0xde, 0xf5, 0x1a, 0x61,
-  0x39, 0xed, 0x5e, 0x9e, 0x69, 0x84, 0xe6, 0xe5,
-  0x0d, 0x40, 0x9c, 0xfe, 0xef, 0xdd, 0xd2, 0x0f,
-  0x26, 0xa0, 0x4e, 0x7f, 0x57, 0x29, 0xba, 0xde,
-  0xf1, 0xa6, 0x13, 0x9b, 0x38, 0x34, 0xc2, 0x73,
-  0x04, 0x27, 0x98, 0x4e, 0x31, 0x34, 0xe7, 0xcd,
-  0x36, 0x5c, 0xa2, 0x3a, 0xa0, 0xae, 0x42, 0x09,
-  0x1c, 0xb4, 0x59, 0x84, 0xec, 0x7c, 0xf2, 0xdb,
-  0xe9, 0xfc, 0x06, 0x3c, 0xa8, 0xaa, 0xa8, 0x6d,
-  0x4a, 0x55, 0x8e, 0x15, 0xb2, 0x31, 0x2d, 0x16,
-  0xf5, 0x2a, 0xe2, 0x7d, 0xc6, 0x0e, 0xee, 0x9d,
-  0x3e, 0xee, 0x03, 0x8b, 0x1d, 0x3f, 0xb9, 0x07,
-  0xae, 0x5f, 0xf7, 0x8e, 0x8e, 0x9f, 0x0e, 0x8a,
-  0x21, 0x17, 0x20, 0xf2, 0x5c, 0x8e, 0xd1, 0xbe,
-  0x11, 0x53, 0xff, 0x95, 0xaa, 0xef, 0xaf, 0xbb,
-  0x5b, 0xae, 0xce, 0x9f, 0xff, 0xdd, 0xc7, 0xf2,
-  0xbf, 0xda, 0x6d, 0x35, 0x4b, 0xfd, 0x47, 0x4e,
-  0x1a, 0xd4, 0xf1, 0x01, 0xcf, 0xff, 0xdb, 0xd0,
-  0x22, 0x94, 0x40, 0x30, 0x5b, 0xfd, 0x8d, 0x10,
-  0x1d, 0x8d, 0x44, 0xff, 0xff, 0xbb, 0xee, 0xce,
-  0xac, 0xec, 0x7d, 0xc0, 0xa7, 0x36, 0x08, 0x42,
-  0x54, 0xfe, 0x4c, 0x16, 0xff, 0x63, 0x44, 0x13,
-  0x3f, 0xc9, 0xac, 0x16, 0xff, 0x63, 0x45, 0xf3,
-  0x3e, 0xda, 0xee, 0xe5, 0x78, 0x3f, 0xa6, 0x3a,
-  0x9f, 0xf3, 0xde, 0xfa, 0xfe, 0x6b, 0xbe, 0xb8,
-  0xe9, 0xc1, 0x08, 0x4a, 0x9f, 0xb5, 0x4c, 0x6f,
-  0x12, 0xac, 0x5e, 0x43, 0xc8, 0x99, 0xeb, 0x04,
-  0xff, 0xcf, 0x29, 0x1f, 0xaf, 0x71, 0xe0, 0x5c,
-  0x74, 0xff, 0xf0, 0x2f, 0xf4, 0x06, 0xa6, 0xf9,
-  0xe5, 0x05, 0xc7, 0x4e, 0x08, 0x42, 0x54, 0xfe,
-  0x07, 0x94, 0xee, 0x3f, 0xa2, 0xac, 0x5e, 0x4f,
-  0xff, 0xcb, 0xd0, 0x0d, 0x4d, 0xf1, 0xc6, 0x04,
-  0x0d, 0x57, 0x1e, 0x3a, 0x5f, 0x44, 0x54, 0xde,
-  0x89, 0x0e, 0x55, 0x11, 0xb8, 0x6d, 0x09, 0x22,
-  0x92, 0x35, 0x18, 0xcc, 0xff, 0xb3, 0x48, 0x35,
-  0xa2, 0x77, 0x47, 0x88, 0x22, 0x7f, 0x26, 0x0b,
-  0x7f, 0xb1, 0xa2, 0x08, 0xb1, 0xe4, 0xcf, 0xee,
-  0xfd, 0x04, 0x76, 0x13, 0xa3, 0x93, 0xfc, 0xea,
-  0x5c, 0xff, 0x27, 0x74, 0x0e, 0x53, 0xdf, 0x3a,
-  0x7f, 0xfb, 0xc3, 0xac, 0xa2, 0x6f, 0x5d, 0xca,
-  0x6c, 0xe8, 0x72, 0x21, 0xfa, 0x73, 0x3f, 0xb4,
-  0x0a, 0xaa, 0x1f, 0x7c, 0xe9, 0xed, 0xad, 0xb0,
-  0x9d, 0x3f, 0xfe, 0xbd, 0xee, 0xa6, 0x52, 0xc9,
-  0xac, 0xa5, 0xe2, 0x74, 0xfb, 0x35, 0x50, 0x6b,
-  0xc1, 0xfc, 0x82, 0x47, 0x3f, 0x35, 0x36, 0xbf,
-  0xbb, 0xa7, 0x4f, 0xca, 0x4b, 0x9d, 0x31, 0xe3,
-  0xa3, 0x83, 0xe3, 0xd9, 0x94, 0xe1, 0x06, 0xa7,
-  0x4f, 0xfb, 0xfa, 0xd8, 0x2d, 0xfe, 0xc6, 0x88,
-  0x46, 0x10, 0xf8, 0x6f, 0x1c, 0x9f, 0xfc, 0x98,
-  0xf8, 0x3a, 0xdf, 0x6f, 0x76, 0x54, 0xe9, 0xff,
-  0xef, 0xf7, 0x81, 0xca, 0x7a, 0xac, 0x10, 0x84,
-  0xe9, 0x67, 0x08, 0x9c, 0x59, 0x32, 0x70, 0x42,
-  0x12, 0xa7, 0xfb, 0x39, 0xf1, 0xc5, 0xd9, 0xc1,
-  0x56, 0x2f, 0x26, 0x08, 0x4a, 0x9c, 0x10, 0x84,
-  0xa9, 0xfb, 0xde, 0xe2, 0x89, 0x52, 0xac, 0x5e,
-  0x47, 0x51, 0x6e, 0x14, 0x85, 0xf3, 0x29, 0xf3,
-  0x6f, 0x80, 0x54, 0x55, 0x8d, 0x9c, 0xe0, 0x84,
-  0x25, 0x4e, 0xaa, 0x09, 0x56, 0x2f, 0x25, 0xce,
-  0xcf, 0xfb, 0x4a, 0xb3, 0xf7, 0x1d, 0x47, 0x7b,
-  0x1d, 0x3f, 0x81, 0x1e, 0x36, 0xb9, 0x38, 0x3a,
-  0x7f, 0x6a, 0x98, 0xbb, 0x35, 0x53, 0xa0, 0x51,
-  0x2f, 0x42, 0xce, 0x9b, 0xc2, 0x23, 0xbf, 0x21,
-  0x81, 0x39, 0xfb, 0x93, 0xaf, 0x73, 0xa7, 0xff,
-  0x65, 0xcf, 0xfb, 0xce, 0x32, 0x51, 0x14, 0x74,
-  0xfc, 0xdb, 0xad, 0x36, 0xb1, 0x53, 0xfc, 0x07,
-  0x71, 0xf7, 0x57, 0x77, 0x4e, 0x9e, 0x4f, 0x52,
-  0xe2, 0xa7, 0x04, 0x21, 0x2a, 0x7f, 0xf8, 0x14,
-  0xe7, 0x33, 0xba, 0xa6, 0xd3, 0xaf, 0x15, 0x62,
-  0xf2, 0x58, 0xc8, 0x9e, 0x51, 0xf4, 0x22, 0x74,
-  0xce, 0x2b, 0x7d, 0x2f, 0x65, 0xd4, 0x86, 0xdc,
-  0xff, 0xf9, 0x58, 0xc9, 0xdf, 0xd5, 0x78, 0xbf,
-  0xc5, 0xc7, 0x4f, 0x93, 0x55, 0x5d, 0x87, 0x42,
-  0x1f, 0xe6, 0x95, 0x27, 0xff, 0xb6, 0xbb, 0x3b,
-  0xc7, 0x7c, 0x39, 0xdf, 0xba, 0x74, 0xff, 0xff,
-  0x71, 0x4d, 0x87, 0x2e, 0x36, 0xaf, 0xd5, 0x6f,
-  0x76, 0x3f, 0xa3, 0xa3, 0x11, 0x81, 0xea, 0x70,
-  0x8c, 0xf7, 0x07, 0x93, 0x5d, 0x08, 0x9e, 0x1d,
-  0x32, 0x5b, 0x96, 0xe3, 0x1b, 0x5a, 0x15, 0x42,
-  0x46, 0xa8, 0x57, 0x52, 0x14, 0xbc, 0xc2, 0x13,
-  0xb0, 0xbe, 0xac, 0xa9, 0xdd, 0x47, 0x99, 0x7c,
-  0x33, 0x03, 0x0e, 0x19, 0xcb, 0x93, 0xa7, 0x4f,
-  0xff, 0x67, 0x6d, 0xab, 0xbb, 0x7e, 0xb4, 0xce,
-  0x7c, 0xe9, 0x3e, 0xe3, 0xf0, 0xe0, 0x76, 0x7e,
-  0xa2, 0xdb, 0xa6, 0xd4, 0x74, 0xff, 0xba, 0x9a,
-  0xa7, 0xf3, 0xef, 0xd4, 0xe9, 0xff, 0xab, 0xfb,
-  0x1c, 0x7e, 0xc1, 0x08, 0x4e, 0x9f, 0xfe, 0xea,
-  0x38, 0x00, 0x75, 0xbe, 0xde, 0xec, 0xa9, 0xd1,
-  0x89, 0x82, 0xb1, 0x7d, 0x0f, 0xf9, 0x44, 0x9f,
-  0xc9, 0xd7, 0x77, 0x33, 0x93, 0xa7, 0xf3, 0xb0,
-  0x6b, 0xd4, 0x78, 0xe9, 0xff, 0xe4, 0x5c, 0x83,
-  0x60, 0x75, 0xdc, 0x7b, 0x62, 0x7b, 0xbd, 0xe7,
-  0xff, 0xb3, 0x49, 0xd6, 0xcd, 0x53, 0x63, 0xcb,
-  0x1d, 0x3e, 0xfa, 0xe7, 0x74, 0x74, 0xed, 0x7d,
-  0xcc, 0xe9, 0xfd, 0xaa, 0x6e, 0xdc, 0xfe, 0xce,
-  0x87, 0x93, 0x24, 0xe1, 0x7b, 0xa9, 0xba, 0x26,
-  0xbc, 0x7e, 0x7f, 0xfe, 0xee, 0x56, 0xf0, 0x32,
-  0x9f, 0xdc, 0x59, 0xc8, 0xf9, 0xd3, 0xfe, 0xca,
-  0xdf, 0x82, 0xdf, 0xec, 0x68, 0x81, 0xa7, 0xd9,
-  0xaa, 0x7b, 0x80, 0x45, 0x27, 0x57, 0x67, 0xff,
-  0xff, 0xec, 0xd5, 0x3f, 0xb7, 0x40, 0xa8, 0xff,
-  0xe9, 0x76, 0x70, 0x06, 0x2b, 0xfa, 0xfb, 0x8f,
-  0x10, 0x5c, 0xff, 0xbf, 0xee, 0xb7, 0xf0, 0x05,
-  0xd0, 0x9e, 0x20, 0xb9, 0xff, 0xa9, 0xba, 0x6d,
-  0x3b, 0xa0, 0x2e, 0x84, 0xf1, 0x05, 0xcf, 0xe4,
-  0xdf, 0x74, 0x05, 0xd0, 0x9e, 0x20, 0xb9, 0xf9,
-  0x59, 0xc0, 0x17, 0x42, 0x78, 0x82, 0xe7, 0xff,
-  0xfb, 0xfb, 0xdd, 0xa8, 0x0a, 0xb5, 0x36, 0x3b,
-  0xba, 0xf6, 0x04, 0xf1, 0x05, 0xcc, 0xf8, 0x1c,
-  0x27, 0x38, 0xc9, 0xe2, 0xab, 0xe8, 0x7d, 0x3e,
-  0x8a, 0x2a, 0x8e, 0xec, 0xa3, 0x79, 0xef, 0x1e,
-  0x7c, 0xe9, 0xff, 0xa9, 0xba, 0x6d, 0x3b, 0xa0,
-  0x2e, 0x84, 0xf1, 0x05, 0xcf, 0xf2, 0xd5, 0x6d,
-  0xbc, 0x05, 0xd0, 0x9e, 0x20, 0xb9, 0xf6, 0xaa,
-  0x8a, 0x01, 0x91, 0x40, 0x0a, 0xac, 0xff, 0xe0,
-  0x1a, 0x9b, 0x64, 0xd5, 0x40, 0xba, 0x13, 0xc4,
-  0x17, 0x3f, 0xff, 0xf7, 0x7b, 0xb5, 0x01, 0x7e,
-  0x01, 0x56, 0xa6, 0xc7, 0x77, 0x5e, 0xc0, 0x9e,
-  0x20, 0xb8, 0xc4, 0xc8, 0x1f, 0x41, 0xf5, 0xa9,
-  0xfe, 0xa6, 0xc7, 0x77, 0x5e, 0xc0, 0x9e, 0x20,
-  0xb9, 0xff, 0xef, 0xf7, 0xdd, 0x5a, 0x6f, 0x8e,
-  0x10, 0x50, 0xa9, 0xff, 0x63, 0x9d, 0x7d, 0x47,
-  0xaf, 0x2f, 0x9e, 0x20, 0xb8, 0x64, 0x74, 0x0a,
-  0x45, 0x54, 0x27, 0xfc, 0xdb, 0x1d, 0x7f, 0x35,
-  0x00, 0x27, 0x88, 0x2e, 0x7e, 0xa6, 0xe9, 0x4d,
-  0xf2, 0x68, 0x02, 0xe7, 0xd9, 0xc8, 0x17, 0x42,
-  0x78, 0x82, 0xe6, 0xcd, 0x31, 0xfa, 0x50, 0xf2,
-  0x1f, 0x47, 0x65, 0x61, 0x81, 0x3f, 0x2b, 0x38,
-  0x02, 0xe8, 0x4f, 0x10, 0x5c, 0xff, 0x9a, 0x9b,
-  0x1d, 0xdd, 0x7b, 0x02, 0x78, 0x82, 0xe6, 0xc0,
-  0x3d, 0x11, 0x75, 0x3e, 0x9f, 0xd7, 0xed, 0x5f,
-  0xd7, 0xdc, 0x78, 0x82, 0xe7, 0xfd, 0x9b, 0x5d,
-  0x9d, 0xce, 0x3d, 0xc7, 0x88, 0x2d, 0x47, 0x85,
-  0x1c, 0x2e, 0xdf, 0xf2, 0x59, 0xd8, 0xf8, 0x2b,
-  0x18, 0xc6, 0xa3, 0x1a, 0xbe, 0x16, 0x81, 0x70,
-  0x9f, 0x73, 0x5e, 0x79, 0x43, 0x44, 0x17, 0x64,
-  0x40, 0xcf, 0xfb, 0x1d, 0x4f, 0x75, 0xc5, 0xc5,
-  0xef, 0x1d, 0x3f, 0x87, 0xb9, 0xc5, 0x2f, 0x09,
-  0xd3, 0xe7, 0xf5, 0xe3, 0xc9, 0xd3, 0xf6, 0x3d,
-  0xf4, 0x4b, 0x99, 0xd1, 0xb4, 0x46, 0x79, 0xa7,
-  0x4a, 0x27, 0x78, 0xbc, 0x74, 0xdc, 0xa1, 0xd3,
-  0xdb, 0x45, 0x61, 0xd0, 0x74, 0xfd, 0xf7, 0x74,
-  0x83, 0xc9, 0xd1, 0xc1, 0xb8, 0xe8, 0x54, 0xff,
-  0xfe, 0x4d, 0xf1, 0xd4, 0xbd, 0xb5, 0x8d, 0xc2,
-  0x30, 0x2a, 0x3a, 0x6e, 0x50, 0xe9, 0x92, 0xe9,
-  0xd3, 0xfd, 0x9a, 0xaa, 0x28, 0x1c, 0x58, 0xe9,
-  0xfd, 0x5c, 0xa6, 0xeb, 0x7b, 0xc7, 0x4c, 0x10,
-  0x95, 0x3f, 0xdd, 0xc5, 0xde, 0xea, 0xef, 0x83,
-  0xa1, 0x93, 0xf8, 0xd8, 0xd8, 0x8b, 0x29, 0x62,
-  0x84, 0x5c, 0xb0, 0xaf, 0x42, 0xdd, 0x17, 0xa9,
-  0xc8, 0x4d, 0x41, 0x16, 0x9c, 0x10, 0x84, 0xa9,
-  0x28, 0xab, 0x17, 0x93, 0xef, 0x5b, 0xfc, 0x4a,
-  0xb2, 0x36, 0x41, 0x85, 0xd4, 0xfe, 0x7f, 0x49,
-  0x94, 0xc7, 0x8e, 0x84, 0x6c, 0x63, 0x32, 0x32,
-  0xfb, 0xa7, 0xaf, 0x99, 0x6e, 0x35, 0x6a, 0x43,
-  0xcb, 0xe9, 0x21, 0xdd, 0x49, 0xac, 0x34, 0xaf,
-  0x96, 0x00, 0xb9, 0x2a, 0x7b, 0x19, 0x34, 0x74,
-  0xf6, 0x2b, 0x34, 0x74, 0xf7, 0xbc, 0x0b, 0x8e,
-  0x84, 0x3e, 0x27, 0xc7, 0xee, 0x08, 0x27, 0xee,
-  0xdf, 0xc2, 0xbd, 0xc7, 0x4f, 0xff, 0x3e, 0xee,
-  0xa0, 0x0a, 0xea, 0x5d, 0xd6, 0xde, 0x3a, 0x11,
-  0x10, 0x9b, 0x2f, 0x9e, 0x03, 0xc0, 0x04, 0xe9,
-  0xf9, 0xe5, 0x9c, 0xbc, 0x17, 0x8e, 0x99, 0xcf,
-  0x1d, 0x3e, 0xa6, 0x6d, 0xd5, 0x3a, 0x7f, 0xfa,
-  0x88, 0x0d, 0xb5, 0xdf, 0xe6, 0xb5, 0x4e, 0x4a,
-  0x9f, 0xdc, 0xe0, 0xb7, 0xfb, 0x1e, 0x20, 0x48,
-  0x72, 0x2d, 0x78, 0x27, 0x15, 0x29, 0xed, 0x3d,
-  0xfd, 0x3a, 0x79, 0xfa, 0xfe, 0x8e, 0x8c, 0x3c,
-  0x4a, 0x11, 0x4f, 0xee, 0xf8, 0x6b, 0x54, 0xe4,
-  0xe9, 0xc1, 0x08, 0x4f, 0x87, 0xd4, 0xef, 0xef,
-  0x05, 0xc3, 0xea, 0xc6, 0xa6, 0x38, 0x44, 0xaf,
-  0x2b, 0x93, 0xff, 0xec, 0xee, 0xee, 0xda, 0xba,
-  0xa5, 0xfe, 0xe7, 0x21, 0xd0, 0xf1, 0xfe, 0xdd,
-  0x25, 0x8b, 0x90, 0xab, 0x31, 0xc6, 0x99, 0x0c,
-  0xcd, 0xba, 0x7c, 0x66, 0x73, 0xed, 0xe9, 0x35,
-  0x52, 0xa7, 0x99, 0x35, 0x52, 0xa6, 0x08, 0x4a,
-  0x87, 0x1e, 0xee, 0x13, 0x84, 0x82, 0x6c, 0x09,
-  0x56, 0x35, 0xd3, 0xff, 0xec, 0xd2, 0x36, 0x67,
-  0x75, 0x4d, 0xa7, 0x5e, 0x3a, 0x39, 0x3f, 0x80,
-  0x92, 0xcf, 0xff, 0xe4, 0x5d, 0xbe, 0xf2, 0x06,
-  0xab, 0x8d, 0x4f, 0xee, 0xaa, 0x74, 0xfe, 0x59,
-  0xf7, 0x52, 0xf4, 0x13, 0xa7, 0x3b, 0xc4, 0xe9,
-  0xf3, 0xb3, 0x59, 0xc1, 0x52, 0xda, 0xc7, 0x83,
-  0xa1, 0xa9, 0xb9, 0x43, 0xa6, 0xe5, 0x0e, 0x9f,
-  0xbb, 0x7b, 0xb3, 0xb6, 0xd9, 0xac, 0xe4, 0x5a,
-  0x7f, 0xed, 0x53, 0x14, 0x0a, 0x73, 0x8f, 0xe8,
-  0xe9, 0xfc, 0xfb, 0x6c, 0x41, 0x4e, 0x0e, 0x9e,
-  0xe5, 0x5e, 0xea, 0x9f, 0xd6, 0x91, 0xa7, 0x2f,
-  0xe3, 0xe7, 0x42, 0x1e, 0xcf, 0x9d, 0x4e, 0x08,
-  0x42, 0x54, 0xfc, 0x99, 0x77, 0xb7, 0xd4, 0xab,
-  0x17, 0x93, 0xc1, 0xfe, 0xb8, 0xe9, 0x9a, 0x87,
-  0x4e, 0x08, 0x42, 0x54, 0xfd, 0xbf, 0xbb, 0x4d,
-  0xe8, 0xab, 0x17, 0x93, 0xec, 0xe7, 0x31, 0x63,
-  0xa5, 0x50, 0x11, 0x2c, 0x26, 0x3d, 0x3e, 0x9e,
-  0xdf, 0x6f, 0x77, 0x08, 0xed, 0xc8, 0x5b, 0xc2,
-  0x2e, 0x09, 0xb8, 0x8f, 0x19, 0x2e, 0xbb, 0x0a,
-  0xad, 0x23, 0x19, 0xa9, 0xe6, 0xa3, 0x2b, 0x9f,
-  0x91, 0x42, 0x3f, 0xa3, 0xa7, 0xff, 0xb6, 0xa7,
-  0xdd, 0x50, 0x33, 0xbd, 0xcd, 0xf2, 0x74, 0x50,
-  0xff, 0x74, 0x55, 0x2b, 0x2f, 0x67, 0xe7, 0xd6,
-  0x49, 0x42, 0xcf, 0x46, 0x2a, 0xe9, 0x41, 0x9c,
-  0x4a, 0x5e, 0xca, 0xd3, 0xf6, 0xec, 0x66, 0xcd,
-  0x1d, 0x13, 0xf2, 0x88, 0xf7, 0x09, 0xd5, 0xa3,
-  0xcf, 0x19, 0xc7, 0xe5, 0x46, 0xe7, 0x49, 0xd1,
-  0x8f, 0x97, 0x63, 0xcc, 0xa0, 0xee, 0xce, 0x60,
-  0x56, 0x9f, 0x73, 0xaa, 0xcc, 0x76, 0xf8, 0xca,
-  0x17, 0x42, 0xd8, 0x24, 0x4b, 0xf2, 0xbc, 0x01,
-  0x9d, 0x71, 0xb8, 0x87, 0xe4, 0x59, 0xfa, 0x8c,
-  0x1d, 0x7d, 0x04, 0x53, 0xfa, 0xd8, 0x2d, 0xfe,
-  0xc6, 0x8b, 0x8e, 0x7f, 0x5b, 0x05, 0xbf, 0xd8,
-  0xd1, 0x75, 0xcf, 0xfd, 0x6f, 0x75, 0xb0, 0x5b,
-  0xfd, 0x8d, 0x12, 0x8c, 0x23, 0xf6, 0xc1, 0xb8,
-  0xa3, 0x83, 0xbb, 0xa7, 0x6c, 0x77, 0xb8, 0x78,
-  0x5c, 0xd0, 0x3e, 0xfa, 0xa0, 0xaa, 0x6d, 0xa3,
-  0xbb, 0x83, 0xb9, 0xff, 0xd6, 0x57, 0xba, 0xd8,
-  0x2d, 0xfe, 0xc6, 0x89, 0x6a, 0x7c, 0x2d, 0xfe,
-  0xc6, 0x88, 0xde, 0x7f, 0xde, 0xeb, 0x60, 0xb7,
-  0xfb, 0x1a, 0x25, 0xf9, 0x5b, 0x0f, 0xd9, 0x46,
-  0x13, 0xfa, 0xd8, 0x2d, 0xfe, 0xc6, 0x8a, 0xae,
-  0x7f, 0xae, 0xe7, 0x71, 0xfd, 0x7a, 0x8e, 0x9b,
-  0x8d, 0x9d, 0x3f, 0x60, 0xb7, 0xfb, 0x1a, 0x24,
-  0x08, 0x00, 0xf3, 0x2c, 0x2f, 0x3e, 0xaf, 0xf7,
-  0xdf, 0x3a, 0x1c, 0x79, 0x4f, 0x91, 0xc5, 0xd4,
-  0x79, 0xfc, 0x34, 0x27, 0xfe, 0xee, 0x3d, 0x65,
-  0xf4, 0xef, 0x73, 0x47, 0x45, 0x8f, 0xc0, 0x4a,
-  0x67, 0xf5, 0xb0, 0x5b, 0xfd, 0x8d, 0x16, 0x44,
-  0xfe, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0xd7, 0x9f,
-  0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x5c, 0x93, 0xe1,
-  0x6f, 0xf6, 0x34, 0x5d, 0x93, 0xfe, 0xf7, 0x5b,
-  0x05, 0xbf, 0xd8, 0xd1, 0x47, 0x4a, 0xd8, 0x7e,
-  0xca, 0x30, 0x9f, 0x0b, 0x7f, 0xb1, 0xa2, 0x95,
-  0x9f, 0xff, 0xfe, 0xa2, 0x3c, 0x94, 0xda, 0xef,
-  0xe2, 0x9b, 0xb3, 0x53, 0x6b, 0x51, 0x1e, 0xc3,
-  0xa7, 0xd6, 0x57, 0xba, 0xd8, 0x8b, 0x25, 0x8c,
-  0x21, 0xe5, 0xce, 0xe7, 0x43, 0x21, 0xf2, 0x7d,
-  0xc7, 0x3c, 0xa2, 0x1e, 0x4e, 0xea, 0x77, 0xa8,
-  0x58, 0xae, 0x86, 0xcc, 0xff, 0x3a, 0xd8, 0x2d,
-  0xfe, 0xc6, 0x88, 0xe2, 0x7f, 0xb7, 0x6c, 0x16,
-  0xff, 0x63, 0x45, 0x6b, 0x2b, 0x7a, 0x20, 0xb4,
-  0x83, 0x3f, 0xfa, 0xca, 0xf7, 0x5b, 0x05, 0xbf,
-  0xd8, 0xd1, 0x2d, 0xcd, 0x8f, 0x9d, 0x3f, 0xb8,
-  0xc5, 0x29, 0x37, 0x53, 0xa1, 0xf3, 0xc9, 0xd8,
-  0xb4, 0xea, 0x70, 0xe3, 0xa7, 0x39, 0x4c, 0x74,
-  0x1a, 0x21, 0xb9, 0xff, 0x7b, 0xad, 0x82, 0xdf,
-  0xec, 0x68, 0x98, 0x27, 0x0d, 0xfc, 0x95, 0x2b,
-  0x22, 0x35, 0x5e, 0x23, 0xe0, 0x75, 0x86, 0xd4,
-  0x2f, 0xa4, 0x69, 0xca, 0xbc, 0x4a, 0x9f, 0xf7,
-  0xba, 0xd8, 0x2d, 0xfe, 0xc6, 0x89, 0x8e, 0x56,
-  0xd9, 0xf1, 0x28, 0x72, 0x7e, 0x4a, 0x81, 0xac,
-  0xa1, 0xd3, 0xff, 0xff, 0xce, 0xad, 0x32, 0xf0,
-  0xd6, 0x98, 0xd9, 0x50, 0x31, 0xf7, 0x57, 0x7d,
-  0xd9, 0xd3, 0xcd, 0xfe, 0xc6, 0x8a, 0xc6, 0x7f,
-  0xcb, 0xf9, 0xae, 0xe5, 0xe9, 0xdd, 0x1d, 0x17,
-  0x53, 0x19, 0x7c, 0xb4, 0x61, 0x01, 0xa2, 0xb9,
-  0xff, 0xc9, 0xdd, 0x5d, 0xbd, 0x3b, 0x8c, 0x82,
-  0x74, 0xff, 0xb3, 0x8a, 0x65, 0x5f, 0x72, 0x50,
-  0xe9, 0xff, 0xff, 0xbb, 0x7b, 0xd8, 0xc0, 0x76,
-  0xfb, 0x80, 0x31, 0xf7, 0x65, 0xfd, 0xe6, 0xa7,
-  0x4f, 0xeb, 0x90, 0xf2, 0xce, 0x5e, 0x0b, 0xc7,
-  0x4e, 0xa6, 0xed, 0x89, 0xc5, 0x32, 0x2d, 0x12,
-  0x74, 0x7e, 0xbe, 0xfb, 0x35, 0xeb, 0x1d, 0x3e,
-  0xfe, 0xbd, 0x7d, 0x4e, 0x8e, 0x9e, 0x0d, 0x46,
-  0x27, 0xc1, 0xad, 0x53, 0x93, 0xa7, 0xc8, 0xee,
-  0x6f, 0x71, 0xd3, 0x93, 0xae, 0x3a, 0x16, 0x3c,
-  0x4d, 0x14, 0xcf, 0xc8, 0xac, 0xee, 0xee, 0x9d,
-  0x2a, 0x9d, 0x1b, 0x37, 0xde, 0x5d, 0x37, 0x28,
-  0x54, 0xc1, 0x09, 0x51, 0xb3, 0x58, 0x11, 0x69,
-  0xfd, 0xee, 0xee, 0x6a, 0x9b, 0x2a, 0xc6, 0x86,
-  0x7b, 0x8f, 0x7e, 0xa7, 0x4e, 0x4e, 0xac, 0x74,
-  0xdd, 0x43, 0xa1, 0x63, 0x62, 0x23, 0x93, 0xc3,
-  0xce, 0x5c, 0x1d, 0x38, 0x11, 0xba, 0x74, 0x22,
-  0x2d, 0xf1, 0x53, 0x64, 0x34, 0x24, 0x9a, 0x9a,
-  0x3a, 0x70, 0x42, 0x12, 0xa7, 0xfe, 0xc6, 0xe1,
-  0x1e, 0x07, 0x29, 0xef, 0x95, 0x62, 0xf2, 0x7e,
-  0xbd, 0x5b, 0xd7, 0x3e, 0x74, 0xfe, 0x6d, 0xd7,
-  0xb8, 0xbb, 0xce, 0x9b, 0x34, 0x74, 0x3e, 0x79,
-  0x14, 0x33, 0x9f, 0xfe, 0xd6, 0xeb, 0x4c, 0xe3,
-  0xb8, 0xbb, 0xb9, 0x53, 0xa5, 0x64, 0x5c, 0x02,
-  0xe0, 0x8b, 0x1b, 0x05, 0x85, 0x4d, 0xb4, 0x87,
-  0xcf, 0x9d, 0xf4, 0xca, 0xaa, 0x9a, 0x77, 0x04,
-  0x8e, 0x7c, 0x2d, 0xfe, 0xc6, 0x8a, 0xde, 0x7f,
-  0xde, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x27, 0x09,
-  0x5b, 0x0f, 0xd9, 0x46, 0x13, 0xe1, 0x6f, 0xf6,
-  0x34, 0x5a, 0x33, 0xd8, 0xb6, 0xee, 0x9d, 0x2b,
-  0x61, 0xea, 0x50, 0xc2, 0x79, 0xbf, 0xd8, 0xd1,
-  0x6d, 0x4f, 0xd4, 0x45, 0x26, 0xf8, 0x3a, 0x6b,
-  0x60, 0x9e, 0xc6, 0x8a, 0xe7, 0xf5, 0xb0, 0x5b,
-  0xfd, 0x8d, 0x17, 0x2c, 0xfe, 0xb6, 0x0b, 0x7f,
-  0xb1, 0xa2, 0xed, 0x84, 0x66, 0x3c, 0xbc, 0x50,
-  0xe8, 0xdc, 0x38, 0x85, 0xfd, 0xd9, 0x59, 0x7b,
-  0x9c, 0xa1, 0xb9, 0xc6, 0x35, 0x47, 0xbe, 0xbf,
-  0xd4, 0xb3, 0x47, 0x73, 0xfa, 0xd8, 0x2d, 0xfe,
-  0xc6, 0x8a, 0x9e, 0x79, 0xbf, 0xd8, 0xd1, 0x5c,
-  0xcf, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x2c, 0xe8,
-  0x13, 0xe6, 0xa1, 0x5c, 0xff, 0x3a, 0xd8, 0x2d,
-  0xfe, 0xc6, 0x89, 0x0a, 0x79, 0x7b, 0x51, 0x14,
-  0x74, 0xfe, 0xca, 0x56, 0xb8, 0x2f, 0x1d, 0x2b,
-  0x62, 0x2e, 0xfc, 0x86, 0xa8, 0x3a, 0x27, 0x9f,
-  0xfd, 0x65, 0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68,
-  0x9f, 0x21, 0x93, 0xef, 0xb9, 0xc6, 0xb9, 0x44,
-  0x19, 0xf0, 0xb7, 0xfb, 0x1a, 0x2b, 0x29, 0xff,
-  0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68, 0x9b, 0xa6,
-  0xdd, 0xb0, 0xfd, 0x94, 0x61, 0x3f, 0xfa, 0xca,
-  0xf7, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x2b, 0x4f,
-  0x85, 0xbf, 0xd8, 0xd1, 0x2e, 0x4f, 0x2e, 0xdf,
-  0x50, 0xe9, 0xf5, 0x95, 0xee, 0xb6, 0x1e, 0x9f,
-  0x98, 0x4f, 0xfd, 0x6f, 0x75, 0xb0, 0x5b, 0xfd,
-  0x8d, 0x11, 0xdc, 0xff, 0x6a, 0x98, 0xeb, 0x7f,
-  0x6a, 0x74, 0xfc, 0xbc, 0xea, 0x36, 0x74, 0xe9,
-  0xfa, 0xe5, 0xee, 0x53, 0xf4, 0x74, 0xf8, 0x5b,
-  0xfd, 0x8d, 0x15, 0x0c, 0xfb, 0x29, 0xac, 0x78,
-  0xe9, 0x5a, 0xe5, 0x45, 0xba, 0xf0, 0xbf, 0x0c,
-  0x74, 0x61, 0x3e, 0x16, 0xff, 0x63, 0x45, 0x51,
-  0x3f, 0xef, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x13,
-  0x5c, 0xad, 0x87, 0xec, 0xa3, 0x09, 0xfd, 0x6c,
-  0x16, 0xff, 0x63, 0x45, 0x59, 0x3f, 0xf5, 0xbd,
-  0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x48, 0x93, 0xe1,
-  0x6f, 0xf6, 0x34, 0x5a, 0x53, 0xfe, 0xf7, 0x5b,
-  0x05, 0xbf, 0xd8, 0xd1, 0x3e, 0xca, 0xd8, 0x7e,
-  0xca, 0x30, 0x9f, 0xfd, 0x65, 0x7b, 0xad, 0x82,
-  0xdf, 0xec, 0x68, 0xa1, 0x27, 0xd4, 0xdb, 0xc8,
-  0x27, 0x4f, 0x85, 0xbf, 0xd8, 0xd1, 0x47, 0xcf,
-  0xff, 0xd9, 0xc5, 0x10, 0x1b, 0x6b, 0xbf, 0xcd,
-  0x6a, 0x9c, 0x95, 0x3e, 0xb2, 0xbd, 0xd6, 0x44,
-  0x5a, 0xe1, 0x3a, 0xf9, 0x84, 0x22, 0xeb, 0xf3,
-  0xd0, 0xa5, 0x71, 0xee, 0x26, 0x5d, 0x87, 0x7b,
-  0x43, 0x05, 0xf2, 0x75, 0x8e, 0xe9, 0x0c, 0x2e,
-  0x49, 0xf5, 0x18, 0x3c, 0xfe, 0xb6, 0x0b, 0x7f,
-  0xb1, 0xa2, 0x22, 0x9f, 0xb0, 0x5b, 0xfd, 0x8d,
-  0x11, 0x5c, 0xff, 0x5c, 0xed, 0x82, 0xdf, 0xec,
-  0x68, 0xae, 0x22, 0xc7, 0xf5, 0xe6, 0xb3, 0xd9,
-  0x4f, 0xd1, 0xd3, 0xfb, 0x36, 0x3c, 0xf3, 0x7d,
-  0x4e, 0x95, 0xcb, 0xd3, 0xd5, 0xa9, 0x04, 0xff,
-  0xdf, 0xb7, 0x6f, 0xba, 0xbe, 0x83, 0x87, 0x4f,
-  0xb3, 0x7c, 0x0e, 0x1d, 0x3b, 0x55, 0xdd, 0x0f,
-  0xab, 0x48, 0x93, 0xe1, 0x6f, 0xf6, 0x34, 0x53,
-  0xd0, 0xbc, 0x47, 0xda, 0x42, 0x5f, 0x0d, 0x27,
-  0xff, 0x7b, 0xad, 0xc7, 0x7c, 0x35, 0xaa, 0x72,
-  0x74, 0x59, 0x10, 0x5c, 0x1b, 0xce, 0xb7, 0x18,
-  0x74, 0xf9, 0x1d, 0xcd, 0xee, 0x3a, 0x79, 0xbf,
-  0xd8, 0xd1, 0x59, 0xc2, 0xc7, 0xa8, 0x25, 0x33,
-  0xf3, 0xca, 0x4e, 0xba, 0xa7, 0x4e, 0x47, 0xb6,
-  0x74, 0xfb, 0x5c, 0x83, 0xd7, 0x1d, 0x3e, 0xc5,
-  0x9e, 0xbf, 0x93, 0xa5, 0x6c, 0x46, 0x08, 0x91,
-  0x50, 0xbb, 0xc7, 0x01, 0x2a, 0x9f, 0xfa, 0xde,
-  0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x24, 0x59, 0xfd,
-  0x6c, 0x16, 0xff, 0x63, 0x45, 0x93, 0x3f, 0xad,
-  0x82, 0xdf, 0xec, 0x68, 0xb6, 0x27, 0xf5, 0xb0,
-  0x5b, 0xfd, 0x8d, 0x16, 0xdc, 0xff, 0x97, 0x8b,
-  0xcb, 0x92, 0xd5, 0x33, 0xa9, 0xc9, 0xd3, 0xf2,
-  0x75, 0xdc, 0x5e, 0xa3, 0xa7, 0xc2, 0xdf, 0xec,
-  0x68, 0xbc, 0x27, 0xb4, 0xbf, 0x94, 0x3a, 0x7d,
-  0x9d, 0xe6, 0xe1, 0x0e, 0x9f, 0x20, 0x37, 0xfd,
-  0x4e, 0x9d, 0xa4, 0xe4, 0xe9, 0x5a, 0xe4, 0xd4,
-  0xcf, 0xde, 0x4e, 0xc2, 0xf7, 0xcc, 0x39, 0x24,
-  0xe9, 0x56, 0x8a, 0x27, 0xc2, 0xdf, 0xec, 0x68,
-  0xbd, 0x27, 0xfd, 0xdf, 0xd3, 0x92, 0xee, 0xb6,
-  0xf1, 0xd3, 0xec, 0x55, 0x3f, 0x83, 0xa5, 0x6c,
-  0x44, 0xc0, 0x26, 0x17, 0x08, 0x30, 0x8b, 0xf9,
-  0xcf, 0x42, 0xd7, 0x23, 0xf3, 0x62, 0x4d, 0xc6,
-  0x62, 0x29, 0xca, 0x4c, 0xe4, 0xef, 0xa7, 0x77,
-  0xc6, 0xf4, 0x18, 0xc3, 0xa7, 0xb2, 0x9f, 0xa3,
-  0xa7, 0xf6, 0x6c, 0x79, 0xe6, 0xfa, 0x9d, 0x2b,
-  0x97, 0xa7, 0xab, 0x52, 0x09, 0xf0, 0xb7, 0xfb,
-  0x1a, 0x22, 0x39, 0xff, 0xea, 0x5f, 0x5a, 0xe2,
-  0xbb, 0x8b, 0x80, 0x45, 0xee, 0x74, 0xff, 0x9c,
-  0x8f, 0x0e, 0x6b, 0x5b, 0xd1, 0xd3, 0x3c, 0xa2,
-  0xa6, 0x08, 0x4a, 0x9f, 0xf9, 0xd6, 0x6a, 0x6d,
-  0x6a, 0x23, 0xd6, 0xe4, 0xd6, 0x84, 0x5e, 0x7f,
-  0x65, 0xcf, 0xb9, 0x4f, 0xd1, 0xd3, 0xff, 0xf3,
-  0x58, 0x7f, 0xbb, 0xd5, 0x85, 0x35, 0xdf, 0xe4,
-  0xe8, 0x5e, 0x2a, 0x0d, 0xc2, 0xd6, 0x30, 0x7d,
-  0x67, 0xda, 0xf4, 0xbc, 0xb8, 0xd6, 0x7c, 0x2d,
-  0xfe, 0xc6, 0x88, 0xba, 0x7d, 0xae, 0x41, 0xeb,
-  0x8b, 0x67, 0xb4, 0xad, 0x87, 0xcf, 0xe6, 0x11,
-  0x64, 0x7b, 0xba, 0x1a, 0x33, 0xff, 0x2b, 0xdd,
-  0x6c, 0x16, 0xff, 0x63, 0x44, 0xcd, 0x39, 0xf4,
-  0xa9, 0xd3, 0x9b, 0x6a, 0x3a, 0x7f, 0xf6, 0x5c,
-  0x6f, 0x5b, 0x6d, 0xf1, 0xac, 0x63, 0xa7, 0xff,
-  0xdc, 0x6f, 0xaf, 0x65, 0x77, 0xf4, 0xb0, 0x42,
-  0x12, 0xa7, 0x9b, 0xfd, 0x8d, 0x16, 0x7c, 0xff,
-  0xf6, 0xc6, 0x9e, 0x06, 0x2e, 0xee, 0x57, 0x3a,
-  0x74, 0xe0, 0x84, 0x25, 0x4f, 0xfb, 0xdd, 0x5e,
-  0xe3, 0x71, 0x82, 0x55, 0x8b, 0xc9, 0xfe, 0x4a,
-  0x6f, 0x8e, 0xff, 0xac, 0x74, 0xff, 0x6f, 0xbc,
-  0x03, 0xc5, 0xfa, 0xa9, 0xd0, 0xc9, 0xd8, 0x8a,
-  0xc5, 0x0a, 0xf9, 0x6c, 0xd2, 0x5a, 0xe3, 0x99,
-  0xff, 0xff, 0xfb, 0x33, 0x9a, 0xe6, 0x76, 0xe8,
-  0x23, 0xd4, 0xca, 0x5a, 0xbd, 0xc7, 0x95, 0x8a,
-  0x3a, 0x75, 0x51, 0xe3, 0xa7, 0x2f, 0xe5, 0x0e,
-  0x87, 0x23, 0x12, 0xb0, 0x8a, 0xd0, 0xe4, 0xf3,
-  0xfc, 0xde, 0xc7, 0x4f, 0xa9, 0xd4, 0xc1, 0x32,
-  0x7f, 0xdb, 0x17, 0x60, 0xbd, 0x7f, 0xf0, 0x68,
-  0x83, 0x6c, 0x69, 0x67, 0xde, 0xdb, 0x52, 0x1d,
-  0x3f, 0x3a, 0x9d, 0xf7, 0xf4, 0x74, 0xb1, 0x8f,
-  0x4f, 0xa4, 0xb3, 0xff, 0xfe, 0xf0, 0xeb, 0x29,
-  0xa4, 0xce, 0xbf, 0xac, 0x1d, 0xbd, 0xea, 0x3a,
-  0x1c, 0x9a, 0x06, 0x42, 0xbf, 0xa4, 0xd3, 0xf0,
-  0xe7, 0x15, 0xa2, 0x1d, 0x3f, 0xff, 0xaf, 0xef,
-  0xdd, 0x00, 0x1e, 0xfe, 0xab, 0xb7, 0xe9, 0xb0,
-  0x9d, 0x3f, 0xff, 0xd5, 0xaa, 0x0e, 0x92, 0xca,
-  0xcd, 0x54, 0x1a, 0xfb, 0xb0, 0xe9, 0xea, 0x66,
-  0xd7, 0x1d, 0x1b, 0x44, 0x45, 0x19, 0x66, 0x55,
-  0xca, 0x68, 0xbf, 0x27, 0xfe, 0x76, 0xaf, 0x73,
-  0x95, 0xad, 0x22, 0x8e, 0x9f, 0xfb, 0x79, 0xdc,
-  0xca, 0x80, 0xea, 0xa8, 0xe8, 0x7d, 0x11, 0x55,
-  0x46, 0x9e, 0xef, 0x51, 0x8e, 0x84, 0x4c, 0x67,
-  0x82, 0x3c, 0x85, 0x97, 0x92, 0x4f, 0xff, 0xfd,
-  0x70, 0x94, 0xda, 0xac, 0xb3, 0xbc, 0x41, 0xa6,
-  0xdf, 0xab, 0x6d, 0xe3, 0xa7, 0xd7, 0xe5, 0x77,
-  0xd3, 0xa7, 0xc8, 0x0d, 0xff, 0x53, 0xa6, 0x5e,
-  0x94, 0x74, 0xff, 0xff, 0xa9, 0xb7, 0xf5, 0x8f,
-  0xe8, 0x45, 0x35, 0xc8, 0x3d, 0x75, 0x30, 0xe9,
-  0xc1, 0x08, 0x4a, 0x9e, 0xe3, 0x8f, 0xe9, 0x56,
-  0x2f, 0x21, 0x11, 0xb0, 0xc3, 0x7b, 0x84, 0x5c,
-  0xff, 0xd9, 0xd7, 0xf5, 0x83, 0xb7, 0xbd, 0x47,
-  0x4f, 0xb3, 0x4e, 0x55, 0x0e, 0x84, 0x3e, 0xba,
-  0xa2, 0x4d, 0xcd, 0x0e, 0x9f, 0x9e, 0x59, 0xcb,
-  0xc1, 0x78, 0xe9, 0xfd, 0x76, 0x99, 0xaa, 0x6f,
-  0x47, 0x4d, 0xb1, 0x3a, 0x2e, 0x41, 0xff, 0x6c,
-  0xd2, 0x86, 0xb3, 0xff, 0xb8, 0xe1, 0x38, 0x14,
-  0xd6, 0xdb, 0x7c, 0x1d, 0x2b, 0x2f, 0x66, 0x59,
-  0x85, 0xc9, 0x0e, 0x70, 0x37, 0x91, 0xfe, 0xbf,
-  0x18, 0xee, 0xcd, 0x56, 0x8e, 0x24, 0x4d, 0x54,
-  0x59, 0x49, 0x41, 0x3e, 0x83, 0xcb, 0xcf, 0x4a,
-  0x2b, 0x18, 0x06, 0xa1, 0x3c, 0x12, 0x15, 0xf8,
-  0x4a, 0x82, 0x6b, 0x16, 0x66, 0x5a, 0x52, 0x96,
-  0xf9, 0x3f, 0xfa, 0xca, 0xf7, 0x5b, 0x05, 0xbf,
-  0xd8, 0xd1, 0x36, 0x4f, 0xeb, 0x60, 0xb7, 0xfb,
-  0x1a, 0x2a, 0xd9, 0xfc, 0xe7, 0x5f, 0xae, 0xa3,
-  0x8e, 0x9e, 0xca, 0x7e, 0x8e, 0x95, 0xcb, 0x87,
-  0xa9, 0xd3, 0x49, 0xf0, 0xb7, 0xfb, 0x1a, 0x2b,
-  0x49, 0xff, 0xe6, 0x41, 0xce, 0x7d, 0x5e, 0xe4,
-  0xdb, 0x1d, 0x3f, 0xfc, 0xea, 0xe7, 0x51, 0x5f,
-  0x9a, 0xd2, 0x28, 0xe9, 0xb5, 0xa4, 0x44, 0xc7,
-  0xa5, 0xcf, 0xe4, 0x5c, 0x0e, 0xba, 0x9c, 0x9d,
-  0x3f, 0x3d, 0x94, 0xde, 0x28, 0xe9, 0xfe, 0xcb,
-  0x8e, 0xa0, 0x5f, 0x75, 0x4e, 0x9f, 0xce, 0xcd,
-  0x7f, 0x79, 0xbc, 0xe9, 0x59, 0x78, 0x9f, 0xa6,
-  0x16, 0x6e, 0x19, 0x14, 0x2d, 0xf3, 0x6e, 0x96,
-  0xe8, 0xf2, 0x7f, 0x5b, 0x05, 0xbf, 0xd8, 0xd1,
-  0x60, 0x4f, 0x85, 0xbf, 0xd8, 0xd1, 0x3a, 0xcf,
-  0xff, 0xea, 0x23, 0xdc, 0x62, 0xad, 0x5a, 0xe5,
-  0x37, 0x5b, 0xde, 0x3a, 0x7d, 0x65, 0x7b, 0xad,
-  0x88, 0x95, 0x58, 0xc2, 0x7c, 0x2d, 0xfe, 0xc6,
-  0x8b, 0x66, 0x7f, 0xdc, 0xa5, 0x6d, 0x4d, 0xb7,
-  0x89, 0xd2, 0xb6, 0x1f, 0x6f, 0x98, 0x4f, 0x37,
-  0xfb, 0x1a, 0x2e, 0x69, 0x28, 0xe9, 0xad, 0x82,
-  0x6e, 0xc2, 0x57, 0x3f, 0xad, 0x82, 0xdf, 0xec,
-  0x68, 0xbb, 0xe7, 0xad, 0x77, 0x8e, 0x4e, 0x84,
-  0x6c, 0xaf, 0x72, 0x99, 0xb8, 0xc6, 0x0f, 0xa9,
-  0x6e, 0x54, 0x18, 0xb9, 0x2a, 0x1a, 0x1c, 0xc2,
-  0xb6, 0xac, 0x3a, 0x2b, 0x04, 0xee, 0x7f, 0x75,
-  0xec, 0xb8, 0xd2, 0x5d, 0x3a, 0x7c, 0x2d, 0xfe,
-  0xc6, 0x89, 0x5e, 0x7e, 0xa7, 0x17, 0xf8, 0xb8,
-  0xe9, 0xde, 0xeb, 0x22, 0x25, 0xb0, 0xe2, 0xa6,
-  0x13, 0xb4, 0x9c, 0x15, 0x3f, 0xfa, 0x9f, 0xbd,
-  0x23, 0xb6, 0x2f, 0x5f, 0xc9, 0x53, 0xfb, 0xda,
-  0xdc, 0x0a, 0xf5, 0x64, 0x3e, 0x8a, 0x8e, 0x4a,
-  0xca, 0x47, 0xaa, 0xe8, 0x53, 0xcf, 0xfe, 0xb2,
-  0xbd, 0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x4c, 0x33,
-  0xff, 0xf6, 0x58, 0x11, 0xfe, 0x6d, 0x77, 0x4e,
-  0x0a, 0x55, 0xc7, 0x4f, 0xfd, 0x72, 0xe3, 0xee,
-  0xbf, 0xf5, 0xd4, 0x71, 0xd3, 0xfd, 0xd4, 0xf7,
-  0xb5, 0x77, 0xc4, 0xe9, 0xf9, 0x49, 0x9d, 0xd2,
-  0xf9, 0xd3, 0xe4, 0xce, 0xe9, 0x7c, 0xe9, 0xfa,
-  0x9b, 0xd5, 0x7d, 0xf0, 0x0f, 0x61, 0x45, 0xf3,
-  0xff, 0xfe, 0xee, 0x06, 0xe3, 0x59, 0x40, 0x3b,
-  0x8f, 0x6f, 0x3a, 0xfb, 0xaa, 0x74, 0xfc, 0xb8,
-  0x1d, 0x75, 0x39, 0x3a, 0x7f, 0xf2, 0x6b, 0x94,
-  0x76, 0x3f, 0xa7, 0xaf, 0x09, 0xd0, 0x87, 0xfd,
-  0xb3, 0x19, 0xfa, 0xbb, 0xba, 0xaf, 0xd1, 0xd3,
-  0xff, 0xfe, 0x1c, 0x5c, 0x9d, 0xd0, 0x00, 0xf5,
-  0x29, 0xfb, 0xd2, 0x6a, 0xa7, 0x4b, 0x1f, 0x44,
-  0xe8, 0x97, 0xcf, 0x78, 0x3c, 0x61, 0xd2, 0xb2,
-  0xf1, 0x58, 0xd7, 0x09, 0x4d, 0x09, 0x15, 0x91,
-  0xe9, 0x0f, 0x0e, 0xc2, 0xfa, 0xf2, 0x89, 0xf0,
-  0xb7, 0xfb, 0x1a, 0x2a, 0xe9, 0xfe, 0x75, 0xb0,
-  0x5b, 0xfd, 0x8d, 0x11, 0xe4, 0xad, 0x87, 0xe3,
-  0xe6, 0x13, 0xfa, 0xd8, 0x2d, 0xfe, 0xc6, 0x8b,
-  0x06, 0x7f, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x65,
-  0x4f, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x2d, 0x39,
-  0xe6, 0xff, 0x63, 0x45, 0xb9, 0x3f, 0xf2, 0x60,
-  0xe7, 0x40, 0xa6, 0x3e, 0x13, 0xa0, 0x4f, 0xba,
-  0xa5, 0x73, 0xfe, 0xf7, 0x5b, 0x05, 0xbf, 0xd8,
-  0xd1, 0x43, 0xcf, 0xdd, 0x5e, 0x60, 0xa5, 0x4e,
-  0x9f, 0xff, 0xb3, 0x8a, 0x20, 0x36, 0xd7, 0x7f,
-  0x9a, 0xd5, 0x39, 0x2a, 0x56, 0xc4, 0x7a, 0x28,
-  0x86, 0xf4, 0x65, 0xf2, 0xf9, 0xfd, 0x6c, 0x16,
-  0xff, 0x63, 0x45, 0xe7, 0x08, 0xbf, 0x4c, 0xe3,
-  0x0e, 0x14, 0xb2, 0x5b, 0xc3, 0xf0, 0xf2, 0x12,
-  0x65, 0x1d, 0xd0, 0xef, 0xb1, 0xce, 0xae, 0x46,
-  0x9f, 0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x52, 0xd3,
-  0xfa, 0xd8, 0x2d, 0xfe, 0xc6, 0x8b, 0x0a, 0x7f,
-  0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x65, 0xcf, 0xfe,
-  0xb2, 0xbd, 0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x51,
-  0x93, 0xfa, 0xc8, 0xb9, 0x05, 0x39, 0x3a, 0x1c,
-  0x99, 0xb0, 0x9d, 0xa8, 0xee, 0xa7, 0x7a, 0x52,
+  0xd1, 0x3c, 0x4f, 0xfe, 0xb2, 0xbd, 0xd6, 0xc1,
+  0x6f, 0xf6, 0x34, 0x4f, 0xf3, 0xff, 0xac, 0xaf,
+  0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x14, 0x34, 0xff,
+  0xeb, 0x2b, 0xdd, 0x6c, 0x16, 0xff, 0x63, 0x45,
+  0x11, 0x3f, 0xef, 0x75, 0xb0, 0x5b, 0xfd, 0x8d,
+  0x14, 0x8c, 0xff, 0xfd, 0x9c, 0x55, 0x39, 0xdb,
+  0x5d, 0xf0, 0x52, 0x88, 0x02, 0xa5, 0x65, 0x22,
+  0x8d, 0x7d, 0x1a, 0x7f, 0xeb, 0x7b, 0xad, 0x82,
+  0xdf, 0xec, 0x68, 0x94, 0x21, 0xe5, 0xce, 0x57,
+  0x46, 0x90, 0xc6, 0x23, 0x09, 0x75, 0x13, 0x55,
+  0x30, 0x0a, 0x4b, 0xda, 0x95, 0x14, 0xae, 0x87,
+  0xad, 0xe1, 0x64, 0xff, 0xeb, 0x2b, 0xdd, 0x6c,
+  0x16, 0xff, 0x63, 0x44, 0xe7, 0x3f, 0xfa, 0xca,
+  0xf7, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x44, 0xcf,
+  0xfc, 0x2e, 0xb5, 0x77, 0x45, 0x9d, 0xb0, 0x1d,
+  0x02, 0x8e, 0xaa, 0x29, 0x5c, 0xa5, 0x3f, 0xad,
+  0x82, 0xdf, 0xec, 0x68, 0x87, 0x27, 0xc2, 0xdf,
+  0xec, 0x68, 0x8b, 0xe7, 0xdf, 0xa7, 0x25, 0xf2,
+  0xa5, 0x6c, 0x3d, 0x8e, 0x98, 0x4f, 0xfe, 0xb2,
+  0xbd, 0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x4c, 0x93,
+  0xfa, 0xd8, 0x2d, 0xfe, 0xc6, 0x8b, 0x7a, 0x7f,
+  0xf5, 0x95, 0xee, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2,
+  0x93, 0x84, 0x4e, 0x65, 0xd0, 0x93, 0xc2, 0x7a,
+  0x29, 0x2e, 0x3b, 0x9f, 0xd6, 0xc1, 0x6f, 0xf6,
+  0x34, 0x43, 0xb3, 0xff, 0xac, 0xaf, 0x75, 0xb0,
+  0x5b, 0xfd, 0x8d, 0x12, 0xc4, 0xfe, 0xb6, 0x0b,
+  0x7f, 0xb1, 0xa2, 0x30, 0x9f, 0xfa, 0xde, 0xeb,
+  0x60, 0xb7, 0xfb, 0x1a, 0x23, 0xd9, 0xfd, 0x6c,
+  0x16, 0xff, 0x63, 0x45, 0x87, 0x3f, 0xad, 0x82,
+  0xdf, 0xec, 0x68, 0xb9, 0xe1, 0x13, 0x8a, 0x78,
+  0xed, 0xca, 0x5b, 0x3b, 0x52, 0x66, 0x8e, 0xe7,
+  0xf5, 0xb0, 0x5b, 0xfd, 0x8d, 0x10, 0xf4, 0xf8,
+  0x5b, 0xfd, 0x8d, 0x11, 0x34, 0xda, 0x51, 0xd3,
+  0xff, 0xb2, 0xbc, 0xde, 0xa2, 0x6d, 0xfd, 0x22,
+  0x8e, 0x87, 0xcf, 0x8e, 0xa2, 0xd3, 0xda, 0xbb,
+  0xf9, 0x9a, 0x21, 0x79, 0x5b, 0x11, 0xcf, 0x48,
+  0x49, 0xdc, 0x47, 0x3d, 0xaa, 0xef, 0x47, 0x4f,
+  0xfe, 0xda, 0xce, 0xc7, 0xdd, 0xc9, 0x5f, 0xfd,
+  0x3a, 0x6f, 0xbc, 0x3a, 0x57, 0xae, 0x22, 0x1e,
+  0xa4, 0x5e, 0x9b, 0x3e, 0xaf, 0xeb, 0xdc, 0x74,
+  0xf6, 0xe9, 0xb0, 0x1d, 0x38, 0x21, 0x09, 0x53,
+  0xef, 0xee, 0xab, 0x85, 0x58, 0xbc, 0x9f, 0x7e,
+  0x96, 0xcd, 0x1d, 0x1c, 0x22, 0x68, 0x07, 0xdd,
+  0x35, 0x9f, 0xf8, 0x1b, 0x5b, 0x95, 0x53, 0x63,
+  0x75, 0xec, 0xe9, 0xff, 0x6e, 0xfa, 0x75, 0x28,
+  0x9b, 0x51, 0xd3, 0xf6, 0x2e, 0xb9, 0xd9, 0x43,
+  0xa7, 0xb3, 0x8c, 0x78, 0xe8, 0xc4, 0xf3, 0x77,
+  0x0c, 0x05, 0x8c, 0x6a, 0x99, 0xd3, 0xfd, 0x17,
+  0xcf, 0xd8, 0x14, 0xce, 0x36, 0x74, 0xff, 0xff,
+  0xee, 0xf5, 0xf4, 0xbf, 0xdc, 0xe2, 0xbb, 0x5b,
+  0x95, 0x31, 0xf7, 0x0e, 0x04, 0xe9, 0xf6, 0xf5,
+  0x72, 0x3c, 0x74, 0xfe, 0x7d, 0xd4, 0xbf, 0x72,
+  0x3e, 0x74, 0xfe, 0xf0, 0xdc, 0xb2, 0x6b, 0xce,
+  0x8d, 0x9f, 0x5f, 0x4e, 0x21, 0x13, 0x35, 0xc7,
+  0xf1, 0x84, 0xa4, 0xd7, 0x38, 0xe9, 0xdf, 0xaa,
+  0x1d, 0x35, 0xcf, 0x1d, 0x3c, 0x9d, 0xd2, 0xce,
+  0x36, 0x62, 0x37, 0x3f, 0xfe, 0xb9, 0x35, 0xcb,
+  0xb7, 0x5e, 0x72, 0xcd, 0x2f, 0xe6, 0x8e, 0x9f,
+  0xfa, 0xa9, 0x7f, 0x96, 0xbb, 0xfa, 0x4d, 0x1d,
+  0x3f, 0xb9, 0x3e, 0xed, 0xd6, 0xe5, 0x1d, 0x00,
+  0x3f, 0xfe, 0xa3, 0xcf, 0xf8, 0x56, 0xe5, 0x44,
+  0xdb, 0xdf, 0xa3, 0xa1, 0x0f, 0x8e, 0xe2, 0x29,
+  0xff, 0xff, 0xeb, 0xbb, 0x41, 0xea, 0x2d, 0xcb,
+  0x9e, 0xb6, 0xec, 0x7f, 0x58, 0xbb, 0xb9, 0x43,
+  0xa4, 0x87, 0x4f, 0xe7, 0x78, 0xee, 0x88, 0xf9,
+  0xd3, 0xff, 0xff, 0xfb, 0x60, 0xa7, 0x73, 0xdf,
+  0xe5, 0xc5, 0x6e, 0xe5, 0xdc, 0x7d, 0xd9, 0x73,
+  0xdd, 0xcf, 0x7c, 0xe9, 0xdf, 0xec, 0x68, 0xa6,
+  0x23, 0x11, 0x7e, 0xd0, 0x99, 0x9f, 0xf6, 0x75,
+  0xf7, 0x53, 0x48, 0x2b, 0x1d, 0x3e, 0x7f, 0xb8,
+  0xbb, 0x0e, 0x8d, 0x9f, 0x47, 0x9f, 0xcf, 0xf7,
+  0xab, 0x8a, 0xa3, 0xd8, 0x13, 0xa7, 0xff, 0xf7,
+  0x71, 0xb5, 0xa4, 0xd5, 0x16, 0xee, 0x07, 0x92,
+  0x5e, 0x83, 0xa7, 0xfc, 0xc8, 0xaa, 0xe5, 0x33,
+  0x7d, 0x3a, 0x11, 0x14, 0x95, 0x68, 0x9f, 0x0a,
+  0x2e, 0x41, 0x3a, 0x7e, 0xfe, 0xf2, 0xe1, 0x3a,
+  0x74, 0x61, 0xfb, 0xec, 0x8a, 0xe2, 0x68, 0x79,
+  0x76, 0x7f, 0x84, 0xab, 0xe7, 0x0d, 0x1a, 0x1b,
+  0xe4, 0x5b, 0x84, 0x32, 0xc1, 0xe3, 0x0f, 0x15,
+  0x42, 0x3b, 0xa4, 0x3a, 0x8d, 0x52, 0x7b, 0x3b,
+  0x7e, 0xf6, 0x74, 0xff, 0xff, 0xfa, 0xbb, 0xd5,
+  0x70, 0x51, 0x77, 0x25, 0x5d, 0x79, 0xcb, 0x1f,
+  0x76, 0x5d, 0xd0, 0x50, 0xe9, 0x6b, 0x68, 0xb6,
+  0xa1, 0x3c, 0xff, 0xfb, 0x32, 0xbb, 0x6a, 0xe7,
+  0x2a, 0x5d, 0x54, 0xbd, 0x9d, 0x3f, 0xf5, 0x3d,
+  0xfe, 0x4a, 0x4c, 0xee, 0x97, 0xce, 0x96, 0xfa,
+  0x8a, 0x3d, 0x2d, 0x4f, 0x9c, 0x8f, 0xba, 0x87,
+  0x4f, 0xff, 0xff, 0xfb, 0x3b, 0x7f, 0x96, 0xeb,
+  0x75, 0x96, 0xde, 0x91, 0x5d, 0xfb, 0xf5, 0xdd,
+  0xb2, 0xaf, 0x81, 0x38, 0x2a, 0x7f, 0xff, 0xe6,
+  0xd8, 0x78, 0xb8, 0x79, 0x5c, 0x8f, 0x51, 0xab,
+  0x75, 0x5f, 0xf0, 0x9d, 0x35, 0xcf, 0x3e, 0x9a,
+  0x36, 0xca, 0x29, 0x0a, 0x58, 0x45, 0x50, 0x15,
+  0x86, 0x67, 0x63, 0x6f, 0x9f, 0xfc, 0xa6, 0xe5,
+  0x5f, 0x76, 0x2b, 0xfa, 0x03, 0xa7, 0xff, 0xdb,
+  0xee, 0xab, 0x97, 0x9a, 0x5b, 0x2f, 0x7f, 0xd0,
+  0x1d, 0x3f, 0xf2, 0x75, 0xee, 0xe2, 0xea, 0x5c,
+  0x8f, 0x9d, 0x14, 0x45, 0x2d, 0xcb, 0xb3, 0xd9,
+  0xac, 0x5e, 0xce, 0x9c, 0xbf, 0x95, 0x3a, 0x6c,
+  0xe0, 0xe8, 0x79, 0x36, 0xc7, 0x43, 0xbe, 0x84,
+  0x9a, 0x25, 0x5c, 0x3d, 0x3f, 0x70, 0x9d, 0xaf,
+  0xb8, 0xe9, 0xc9, 0xc2, 0x1d, 0x3f, 0x96, 0x76,
+  0x6a, 0x9e, 0xb7, 0x23, 0xc8, 0x51, 0x6c, 0xfd,
+  0x79, 0x5f, 0xbd, 0xa0, 0x0e, 0x9f, 0xc2, 0xb7,
+  0x72, 0xbf, 0xa3, 0xa3, 0x0f, 0x97, 0x66, 0x73,
+  0xf2, 0x03, 0x35, 0xcd, 0xe3, 0xa1, 0xc7, 0xa1,
+  0xd2, 0x19, 0xff, 0xff, 0x6b, 0xbe, 0x0a, 0x3d,
+  0x9b, 0xee, 0xbb, 0x8b, 0xb9, 0x50, 0x3d, 0x3a,
+  0x7f, 0xdb, 0xc5, 0xb9, 0x51, 0x2b, 0xf7, 0xb3,
+  0xa7, 0xf7, 0xbf, 0x4a, 0xe7, 0x89, 0xd1, 0xc1,
+  0xfa, 0xe9, 0x12, 0x4a, 0x3a, 0x77, 0x73, 0x83,
+  0xa1, 0x0d, 0x63, 0xe2, 0x13, 0xf3, 0xf4, 0xcc,
+  0xed, 0xf3, 0xa7, 0x95, 0xcd, 0x00, 0x74, 0x61,
+  0xe9, 0x6c, 0xbe, 0x11, 0x3c, 0xac, 0x87, 0x3e,
+  0xd3, 0xc5, 0xce, 0x7f, 0x6b, 0x6f, 0x65, 0x6e,
+  0xd1, 0xd3, 0xd8, 0xfa, 0x2c, 0x74, 0xfd, 0x5f,
+  0x72, 0x87, 0x67, 0x4f, 0xb6, 0x01, 0xc7, 0xce,
+  0x8b, 0xe8, 0xaa, 0xd9, 0xa8, 0x08, 0xae, 0x2c,
+  0x9f, 0xff, 0x85, 0xd5, 0xc5, 0xaa, 0x9d, 0xbf,
+  0xdc, 0xd5, 0x6e, 0x3a, 0x7f, 0xff, 0x6f, 0x1f,
+  0x75, 0x35, 0x54, 0x52, 0x6f, 0x8e, 0x49, 0x7a,
+  0x0e, 0x9f, 0xff, 0xff, 0x5d, 0xde, 0x41, 0xf7,
+  0xdc, 0x3e, 0x0e, 0x54, 0xb9, 0x1f, 0xae, 0x6f,
+  0xb9, 0x7c, 0xe9, 0xff, 0xf5, 0xc2, 0x39, 0xaa,
+  0x57, 0x79, 0xca, 0xa0, 0x43, 0xa3, 0x11, 0xc5,
+  0x58, 0x46, 0x4f, 0xff, 0x3a, 0xf2, 0xb8, 0x9d,
+  0x5b, 0xb9, 0xaa, 0x79, 0xd3, 0xff, 0xee, 0x31,
+  0x5c, 0xaf, 0x34, 0x94, 0x59, 0xde, 0x2f, 0x1d,
+  0x3f, 0xd9, 0xd7, 0xb9, 0x03, 0xfd, 0x63, 0xa7,
+  0xfd, 0x4b, 0xbb, 0xca, 0x97, 0x2f, 0xdc, 0x27,
+  0x4f, 0xfe, 0x7b, 0x95, 0x2b, 0x77, 0x2d, 0x52,
+  0x88, 0x27, 0x4f, 0xff, 0xfb, 0x1f, 0xa6, 0xf0,
+  0x3c, 0xab, 0x9a, 0xa6, 0x3d, 0xcb, 0x37, 0xc1,
+  0xd1, 0x88, 0xc2, 0xda, 0x84, 0x3c, 0xae, 0x1d,
+  0xa3, 0x4c, 0x7c, 0x9f, 0x6a, 0x4a, 0x5c, 0xa1,
+  0xde, 0xa3, 0x09, 0x9f, 0xf7, 0x8d, 0x73, 0x49,
+  0xdd, 0x80, 0xe9, 0xfe, 0xc0, 0xbe, 0xea, 0x72,
+  0xd6, 0xce, 0x9f, 0xff, 0xf2, 0x32, 0x2b, 0x92,
+  0xd5, 0xdf, 0x78, 0xe5, 0xcd, 0xbb, 0x95, 0xc3,
+  0xa1, 0x91, 0xd5, 0xd3, 0xcb, 0xc3, 0xc9, 0xed,
+  0xeb, 0x68, 0x74, 0xff, 0xff, 0xfd, 0xa4, 0x57,
+  0x77, 0x7e, 0xbe, 0xb7, 0x2e, 0xdd, 0x79, 0xcb,
+  0x1f, 0x76, 0x5d, 0xd0, 0x50, 0xe8, 0x72, 0x2e,
+  0x36, 0x43, 0x08, 0xbc, 0x9f, 0x92, 0xf9, 0x77,
+  0x1a, 0xef, 0xc3, 0xaa, 0x7b, 0x54, 0xf0, 0x1d,
+  0x3f, 0xf5, 0x77, 0xcb, 0x63, 0x73, 0xde, 0x2c,
+  0x74, 0xfd, 0xaf, 0x1e, 0xbf, 0xb3, 0xa3, 0x11,
+  0x29, 0x7c, 0x87, 0x48, 0xd3, 0xdc, 0xee, 0xfa,
+  0x1d, 0x3f, 0xff, 0x6c, 0x79, 0x66, 0xf3, 0xb7,
+  0xeb, 0xbc, 0x56, 0x31, 0xd3, 0xff, 0xfd, 0xb7,
+  0x85, 0x15, 0x4b, 0x93, 0x92, 0x0a, 0x71, 0x54,
+  0x51, 0xd1, 0x88, 0xc4, 0x15, 0xc9, 0xff, 0xff,
+  0xc2, 0x3b, 0x7b, 0x95, 0x73, 0x5d, 0x45, 0xab,
+  0x8f, 0x23, 0xfa, 0xb9, 0x8e, 0x9f, 0xff, 0xf9,
+  0x2f, 0xd5, 0x39, 0x77, 0x2e, 0xbf, 0xc9, 0xf7,
+  0x53, 0x7d, 0xe6, 0x8f, 0x1d, 0x3e, 0x7e, 0x9b,
+  0xce, 0x9d, 0x18, 0x8a, 0x7b, 0x9f, 0xe3, 0x69,
+  0xa3, 0x56, 0x32, 0x39, 0xfe, 0xed, 0xcb, 0x77,
+  0x2b, 0xfa, 0x3a, 0x7f, 0xb8, 0xaa, 0x07, 0x8a,
+  0xfa, 0x8e, 0x9f, 0xff, 0xef, 0x1a, 0xe6, 0xb7,
+  0x9d, 0x7a, 0x89, 0x9d, 0xe2, 0xa8, 0x74, 0xf6,
+  0xb9, 0x3c, 0x27, 0x43, 0xe8, 0x89, 0xf6, 0x59,
+  0xf9, 0x67, 0xdd, 0x72, 0x68, 0xe9, 0xfe, 0xaf,
+  0xab, 0xb9, 0x5f, 0xd1, 0xd0, 0x87, 0xcf, 0x43,
+  0x09, 0xfb, 0x34, 0x23, 0x8e, 0x3a, 0x7e, 0xee,
+  0x57, 0xb8, 0xc7, 0x4f, 0x77, 0x29, 0xc9, 0x63,
+  0xd5, 0xd1, 0x54, 0x70, 0xaf, 0x29, 0xa3, 0x67,
+  0xd9, 0x50, 0x9d, 0x56, 0x18, 0x7a, 0x84, 0x52,
+  0xe7, 0x69, 0xff, 0xbb, 0xdc, 0xe4, 0x39, 0x5e,
+  0xe2, 0xc7, 0x42, 0x2e, 0xb7, 0x64, 0xe5, 0x97,
+  0xbb, 0xcf, 0xba, 0x8a, 0xfe, 0x0e, 0x9f, 0xd8,
+  0xb5, 0x73, 0x49, 0xc1, 0xd3, 0xff, 0xff, 0xd5,
+  0xcd, 0x53, 0xd6, 0xe5, 0xdc, 0x7d, 0xd9, 0x73,
+  0xdd, 0xce, 0x2b, 0xb5, 0x8e, 0x9a, 0xeb, 0xe7,
+  0x40, 0xa2, 0x7b, 0x50, 0x85, 0x9f, 0xb1, 0xee,
+  0xe3, 0xf4, 0x3a, 0x7f, 0xf0, 0xbe, 0xea, 0x62,
+  0x9f, 0x4a, 0xd5, 0x0e, 0x95, 0x0e, 0x8b, 0x8f,
+  0x6b, 0x9a, 0x54, 0xfe, 0x45, 0x77, 0x2b, 0xfa,
+  0x3a, 0x7f, 0xff, 0xda, 0xea, 0x01, 0xf7, 0x52,
+  0xe4, 0xd7, 0x73, 0x8d, 0xe0, 0xac, 0x74, 0x6d,
+  0x53, 0x62, 0xc4, 0xff, 0x0d, 0x1e, 0x93, 0xd2,
+  0x11, 0x17, 0x12, 0xf3, 0x31, 0x9f, 0x3b, 0x63,
+  0x8f, 0x9d, 0x3e, 0xca, 0x3d, 0x81, 0x3a, 0x1f,
+  0x3c, 0xea, 0x93, 0xcf, 0xff, 0xb6, 0xf6, 0x37,
+  0x15, 0xde, 0x5f, 0xe5, 0x7e, 0xe4, 0x3a, 0x7a,
+  0xf3, 0x59, 0x53, 0xa7, 0xff, 0xfe, 0xbc, 0x7d,
+  0xde, 0xff, 0x2e, 0xdd, 0x79, 0xcb, 0x1f, 0x76,
+  0x5d, 0xd0, 0x50, 0xe8, 0x79, 0x14, 0xd8, 0x49,
+  0x3f, 0xff, 0xfe, 0x47, 0xe9, 0x72, 0x3f, 0xca,
+  0xb9, 0xc7, 0x2e, 0xe5, 0xd7, 0xf9, 0x50, 0x00,
+  0xde, 0x8e, 0x9f, 0x27, 0x5f, 0xf7, 0x8e, 0x9f,
+  0xff, 0xff, 0xfd, 0x8a, 0xc6, 0x4a, 0xa2, 0xb5,
+  0x94, 0xa2, 0x08, 0xa7, 0x71, 0xec, 0xba, 0x97,
+  0x2d, 0xd4, 0x51, 0xd3, 0xfc, 0x0c, 0xe3, 0xb9,
+  0x5f, 0xd1, 0xd3, 0xff, 0x3e, 0x97, 0xef, 0x2e,
+  0xce, 0xad, 0xcd, 0x47, 0x4f, 0xff, 0x66, 0xb8,
+  0xcc, 0x05, 0x39, 0x0d, 0x38, 0xa1, 0xd0, 0x8a,
+  0xdf, 0x70, 0x8f, 0x71, 0x81, 0x89, 0x1a, 0xa1,
+  0x23, 0x52, 0x8f, 0x85, 0x1f, 0x4e, 0x28, 0x9d,
+  0x3b, 0x8e, 0x4b, 0x1d, 0x3f, 0xfc, 0xfb, 0xba,
+  0x9c, 0x95, 0xd4, 0xbf, 0xad, 0xbc, 0x74, 0x61,
+  0xfb, 0x6c, 0x82, 0x7e, 0x79, 0x67, 0x2f, 0x05,
+  0xe3, 0xa7, 0xca, 0xdf, 0x19, 0xc1, 0xd2, 0x58,
+  0xe9, 0x91, 0x47, 0x4b, 0x47, 0x40, 0x9a, 0x5f,
+  0x15, 0x8e, 0x0f, 0x56, 0xa6, 0xd3, 0xda, 0xa7,
+  0xbe, 0x74, 0xcb, 0x79, 0xd3, 0xfa, 0xbb, 0x17,
+  0xdd, 0xd4, 0x3a, 0x17, 0xaa, 0x68, 0x08, 0x69,
+  0x8f, 0xdb, 0x23, 0x51, 0x15, 0xc2, 0xd3, 0xfa,
+  0x9b, 0x7c, 0x3f, 0xd0, 0x1d, 0x3f, 0xfe, 0x41,
+  0x46, 0xc5, 0x23, 0x3b, 0x74, 0xb9, 0x47, 0x42,
+  0xc8, 0x86, 0x5f, 0x34, 0x9d, 0xd0, 0x21, 0xd2,
+  0xb2, 0xf1, 0xd5, 0x8e, 0xa4, 0xa0, 0x67, 0x97,
+  0x78, 0x8d, 0x87, 0x27, 0x74, 0x9a, 0x5f, 0x83,
+  0xf1, 0xd4, 0x6e, 0x13, 0x6b, 0x46, 0x06, 0x31,
+  0xf6, 0x2a, 0x1d, 0x55, 0x9e, 0x8f, 0xf8, 0x71,
+  0xf6, 0x76, 0x7e, 0x92, 0xa9, 0x35, 0x38, 0x7c,
+  0xba, 0x30, 0x25, 0xf8, 0xd8, 0x79, 0xc3, 0x8e,
+  0xf0, 0x9e, 0x7f, 0x5b, 0x05, 0xbf, 0xd8, 0xd1,
+  0x4e, 0xcf, 0x85, 0xbf, 0xd8, 0xd1, 0x51, 0xcf,
+  0xfb, 0xdd, 0x6c, 0x16, 0xff, 0x63, 0x44, 0xd1,
+  0x2b, 0x61, 0xfb, 0x28, 0xc2, 0x7f, 0x5b, 0x05,
+  0xbf, 0xd8, 0xd1, 0x57, 0xcf, 0x85, 0xbf, 0xd8,
+  0xd1, 0x5b, 0x4f, 0xf3, 0xad, 0x82, 0xdf, 0xec,
+  0x68, 0x90, 0x65, 0x6c, 0x3f, 0x1f, 0x30, 0x9f,
+  0xfa, 0xde, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x24,
+  0x39, 0xf0, 0xb7, 0xfb, 0x1a, 0x2c, 0x49, 0xff,
+  0x93, 0x29, 0x9d, 0xe3, 0x60, 0x4e, 0x9d, 0x3b,
+  0xa8, 0xf1, 0xd2, 0x77, 0x4f, 0x7e, 0xe4, 0x39,
+  0xcb, 0xfb, 0x01, 0xd3, 0xef, 0x77, 0x3a, 0xa1,
+  0xd3, 0xf5, 0x28, 0x3b, 0x0d, 0xec, 0xe8, 0xd9,
+  0xec, 0xf9, 0x44, 0xfe, 0x02, 0x66, 0xb7, 0xd0,
+  0x95, 0x18, 0x9c, 0x1b, 0xf0, 0x8f, 0xd9, 0x4d,
+  0x5e, 0x00, 0x43, 0x3f, 0xf5, 0x76, 0x9a, 0xaf,
+  0xdf, 0xce, 0x80, 0xe9, 0xff, 0xfd, 0xad, 0x7b,
+  0xa9, 0x9d, 0x45, 0x7e, 0x6b, 0x48, 0xa3, 0xa7,
+  0xff, 0xb1, 0xf7, 0x6a, 0xe7, 0xad, 0x5f, 0x56,
+  0xe8, 0x74, 0xd5, 0xb6, 0x23, 0xdb, 0x68, 0xbd,
+  0x5e, 0x8b, 0x27, 0x02, 0x91, 0xa3, 0x4f, 0xeb,
+  0x60, 0xb7, 0xfb, 0x1a, 0x2c, 0xd9, 0xff, 0xd6,
+  0x57, 0xba, 0xd8, 0x2d, 0xfe, 0xc6, 0x8a, 0x02,
+  0x6e, 0x54, 0x3a, 0x79, 0xbf, 0xd8, 0xd1, 0x6f,
+  0xcf, 0xdc, 0xf5, 0xed, 0xe2, 0x74, 0x09, 0xeb,
+  0x80, 0xae, 0x7d, 0xa7, 0x53, 0x9d, 0x0e, 0x9f,
+  0xc8, 0xbb, 0x9e, 0xba, 0x80, 0x3a, 0x77, 0x71,
+  0xc7, 0x4a, 0xce, 0x4c, 0x2f, 0x1b, 0xc4, 0x86,
+  0xa5, 0x5a, 0x36, 0x9f, 0xf7, 0xba, 0xd8, 0x2d,
+  0xfe, 0xc6, 0x8a, 0x52, 0x7f, 0x9d, 0x6c, 0x16,
+  0xff, 0x63, 0x44, 0x9d, 0x2b, 0x29, 0x10, 0xfe,
+  0x8d, 0x08, 0xed, 0x93, 0x5e, 0x8c, 0x8b, 0x8b,
+  0x57, 0xbf, 0x91, 0xc9, 0xb4, 0x2c, 0x76, 0x4f,
+  0x7b, 0x85, 0x62, 0xc4, 0xca, 0x96, 0xa1, 0x52,
+  0x90, 0x1d, 0xd2, 0x35, 0xd5, 0xd0, 0xd6, 0x9f,
+  0x0b, 0x7f, 0xb1, 0xa2, 0x1f, 0x9f, 0xf7, 0xba,
+  0xd8, 0x2d, 0xfe, 0xc6, 0x89, 0x4e, 0x56, 0xc3,
+  0xf6, 0x51, 0x84, 0xfe, 0xb6, 0x0b, 0x7f, 0xb1,
+  0xa2, 0x27, 0x9f, 0xd6, 0xc1, 0x6f, 0xf6, 0x34,
+  0x46, 0x33, 0xff, 0xac, 0xaf, 0x75, 0xb0, 0x5b,
+  0xfd, 0x8d, 0x13, 0xcc, 0x22, 0x3b, 0xde, 0x27,
+  0x71, 0xdd, 0x4e, 0xe7, 0xc2, 0xdf, 0xec, 0x68,
+  0x88, 0x27, 0xfd, 0xee, 0xb6, 0x0b, 0x7f, 0xb1,
+  0xa2, 0x54, 0x95, 0xb0, 0xfd, 0x94, 0x61, 0x3f,
+  0xad, 0x82, 0xdf, 0xec, 0x68, 0x8a, 0x27, 0xf5,
+  0xb0, 0x5b, 0xfd, 0x8d, 0x11, 0x94, 0xff, 0xeb,
+  0x2b, 0xdd, 0x6c, 0x16, 0xff, 0x63, 0x44, 0xcb,
+  0x3f, 0xad, 0x82, 0xdf, 0xec, 0x68, 0xa9, 0x27,
+  0xf5, 0xb0, 0x5b, 0xfd, 0x8d, 0x15, 0xd4, 0xfe,
+  0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0xc5, 0x9f, 0xf9,
+  0x5e, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x27, 0xa9,
+  0xfe, 0x0d, 0xbd, 0x36, 0xbf, 0xbb, 0xc3, 0xa2,
+  0xc8, 0x8a, 0x44, 0xc9, 0xfa, 0xf4, 0xf9, 0xad,
+  0xdd, 0x43, 0xa7, 0x85, 0x5a, 0x7c, 0xe9, 0xcd,
+  0x95, 0x2a, 0x7f, 0xfe, 0xaf, 0x7e, 0xfe, 0xc5,
+  0x1c, 0xec, 0xa0, 0x00, 0x87, 0x4f, 0xff, 0xc3,
+  0xbb, 0xcf, 0x55, 0x90, 0x47, 0x77, 0x8d, 0x73,
+  0xc7, 0x4f, 0x9b, 0x75, 0xe6, 0xa3, 0xa7, 0xff,
+  0x7d, 0x3b, 0x80, 0xb5, 0x76, 0xde, 0x27, 0x4f,
+  0xb5, 0x54, 0x53, 0x1d, 0x3f, 0xfb, 0xbc, 0x91,
+  0x3a, 0x8a, 0xe5, 0xca, 0xab, 0xe7, 0x4f, 0xf5,
+  0xdf, 0x4f, 0xad, 0xdd, 0x78, 0xe8, 0xda, 0x7b,
+  0xc2, 0xb6, 0xa6, 0x0a, 0x94, 0xf5, 0x1f, 0x44,
+  0xd7, 0x8a, 0x53, 0xbb, 0xfa, 0x35, 0x42, 0xd3,
+  0xbb, 0xba, 0x1d, 0x20, 0xde, 0xa7, 0x88, 0x85,
+  0x13, 0xc2, 0xbb, 0xd4, 0x74, 0x61, 0xe7, 0x6c,
+  0xb2, 0x7f, 0xdb, 0xaf, 0xe9, 0x16, 0xa6, 0xd4,
+  0x74, 0xfd, 0xbe, 0xdf, 0xde, 0x50, 0xe9, 0xee,
+  0xf1, 0xca, 0xf9, 0xd3, 0xf6, 0x50, 0x3f, 0xd7,
+  0x8e, 0x8f, 0x3d, 0x4e, 0x93, 0xcf, 0xae, 0xbf,
+  0x4e, 0x10, 0xe8, 0xc4, 0x67, 0xee, 0x10, 0x75,
+  0x21, 0x9f, 0xff, 0xfd, 0x54, 0xd8, 0x8a, 0x73,
+  0xd6, 0xfb, 0x73, 0xb2, 0x9c, 0x5d, 0xe2, 0xe3,
+  0xa7, 0xcf, 0x70, 0x3b, 0x09, 0xd3, 0xf7, 0x1e,
+  0x20, 0x5f, 0xc3, 0xa7, 0xfd, 0xdd, 0xbb, 0x55,
+  0xc1, 0xdd, 0x0e, 0x9f, 0xf7, 0xe0, 0x13, 0xbf,
+  0xc6, 0x5f, 0x3a, 0x1c, 0x7f, 0x80, 0x3e, 0x9e,
+  0xba, 0x95, 0x51, 0xd3, 0xf5, 0xd4, 0xd5, 0x33,
+  0x47, 0x4e, 0x08, 0x42, 0x54, 0xff, 0xed, 0x6f,
+  0x54, 0xae, 0xd7, 0xf9, 0x8a, 0x38, 0xab, 0x17,
+  0x91, 0xb4, 0x54, 0x5c, 0x95, 0x0e, 0x54, 0xbf,
+  0x8f, 0x5b, 0x29, 0x18, 0x55, 0xf4, 0x8b, 0x50,
+  0xcb, 0x9a, 0xfe, 0x1d, 0x3e, 0x0e, 0x91, 0xf0,
+  0x9d, 0x3f, 0x93, 0xc6, 0xa1, 0xfe, 0x0a, 0x98,
+  0x21, 0x2a, 0x38, 0x3c, 0x70, 0x98, 0xcf, 0x53,
+  0x5b, 0xbd, 0x95, 0x63, 0x47, 0x3f, 0xfa, 0xea,
+  0x53, 0x8e, 0xa7, 0x15, 0x4d, 0x50, 0xe9, 0xff,
+  0x6b, 0x63, 0xe0, 0xbc, 0xd6, 0x54, 0xe8, 0x72,
+  0x23, 0x76, 0x9b, 0x3e, 0xc7, 0xb3, 0x62, 0x74,
+  0xfd, 0xa4, 0x1e, 0x33, 0xa7, 0x4f, 0xee, 0x2a,
+  0x9d, 0x0f, 0xbe, 0x74, 0xff, 0xff, 0xb6, 0xaf,
+  0xeb, 0xee, 0xb0, 0x73, 0x6b, 0xb3, 0xb9, 0xc7,
+  0xb8, 0xf1, 0x7a, 0xc2, 0x23, 0x73, 0xcb, 0x2e,
+  0x34, 0x9f, 0xfe, 0xcd, 0x53, 0x16, 0xaa, 0x2e,
+  0xca, 0xd5, 0x0e, 0x9f, 0xff, 0xff, 0x6f, 0x1f,
+  0xa6, 0xf0, 0x3c, 0xb1, 0xf7, 0x53, 0x7a, 0xa6,
+  0xdf, 0xe3, 0x8b, 0x9e, 0x3a, 0x3a, 0x8d, 0xed,
+  0x28, 0x4d, 0xb0, 0x9d, 0x37, 0x30, 0x1d, 0x0b,
+  0x1a, 0xe0, 0x0b, 0x4e, 0x77, 0xf0, 0x74, 0xc1,
+  0x09, 0xd1, 0xb3, 0xd4, 0xa1, 0x10, 0x47, 0x27,
+  0x6b, 0x98, 0x0a, 0xb1, 0xaf, 0x9f, 0xff, 0xfd,
+  0xa4, 0xe2, 0xb7, 0x7d, 0xf5, 0x7f, 0x19, 0x9d,
+  0xbf, 0x4a, 0x67, 0x40, 0x74, 0x3e, 0x8a, 0xbd,
+  0x97, 0x4f, 0xf6, 0x6a, 0xa8, 0x3a, 0xc6, 0x3a,
+  0x72, 0x0a, 0xc7, 0x46, 0x27, 0xe7, 0xf1, 0xbf,
+  0xf4, 0x91, 0x7c, 0xd6, 0x7d, 0xdc, 0xd7, 0xde,
+  0x1d, 0x3f, 0xf6, 0x08, 0xe2, 0xd5, 0xca, 0x7f,
+  0x4e, 0x9f, 0xdd, 0x41, 0xb9, 0xaa, 0x87, 0x4f,
+  0xb7, 0x7e, 0xbe, 0xe3, 0xa7, 0xed, 0xa2, 0x9e,
+  0xc0, 0x9d, 0x30, 0x42, 0x74, 0x31, 0xf6, 0x09,
+  0x48, 0x4b, 0x67, 0xfb, 0x16, 0xf5, 0xbd, 0xf7,
+  0x50, 0xab, 0x1a, 0xd9, 0xff, 0xd9, 0xd0, 0x65,
+  0x76, 0xfd, 0x2b, 0x75, 0x0e, 0x9f, 0xbb, 0xe0,
+  0xe3, 0x3a, 0x74, 0xe0, 0x84, 0x25, 0x4f, 0xfc,
+  0x83, 0xdb, 0xbf, 0x9e, 0x2c, 0x8a, 0x3a, 0xc5,
+  0xe4, 0x5e, 0xd3, 0xfd, 0x5a, 0x19, 0x54, 0x4a,
+  0xd2, 0x60, 0x52, 0x67, 0x78, 0xbc, 0x79, 0x04,
+  0xa7, 0x9d, 0x8f, 0xb8, 0xf2, 0x09, 0x4e, 0xa6,
+  0xf8, 0x3c, 0x82, 0x53, 0x04, 0x27, 0x90, 0x4a,
+  0x19, 0x14, 0x8b, 0x14, 0x68, 0xbc, 0x25, 0x53,
+  0xf7, 0xf4, 0x1d, 0xfd, 0x16, 0x41, 0x2b, 0x1b,
+  0xd9, 0xe5, 0xfc, 0xfa, 0x9d, 0x2c, 0xbd, 0x9f,
+  0x60, 0x12, 0x67, 0xf2, 0xce, 0xb9, 0xed, 0x6d,
+  0xe2, 0xa7, 0xf6, 0xdd, 0x77, 0xd2, 0xbb, 0x3a,
+  0x4e, 0x2a, 0x77, 0x8b, 0xc5, 0x41, 0x50, 0x86,
+  0xd5, 0x84, 0x14, 0x37, 0x3d, 0xd4, 0x03, 0x15,
+  0x63, 0x59, 0x08, 0x8c, 0x5c, 0x84, 0xac, 0xf5,
+  0xde, 0x2e, 0x3a, 0x4a, 0x3a, 0x6c, 0x77, 0x06,
+  0xc5, 0x62, 0x19, 0xf0, 0x71, 0x6d, 0xa8, 0xe9,
+  0xf9, 0x91, 0x67, 0x20, 0x0a, 0x96, 0xce, 0x9f,
+  0xe7, 0xae, 0x77, 0x15, 0xbb, 0xfa, 0x74, 0xfd,
+  0xb4, 0x53, 0xd8, 0x13, 0xa7, 0xd8, 0xf2, 0xb1,
+  0x47, 0x4e, 0xa6, 0xc4, 0xe8, 0xe9, 0xe1, 0x68,
+  0x9e, 0x7e, 0xef, 0x80, 0x17, 0x50, 0xe9, 0xfb,
+  0x77, 0xf9, 0xa2, 0xad, 0xc2, 0x61, 0x98, 0x20,
+  0x27, 0xb4, 0x6f, 0xd1, 0x14, 0x62, 0x7a, 0x3b,
+  0x28, 0xec, 0x67, 0x13, 0xdd, 0xc7, 0xae, 0x3a,
+  0x1c, 0xaf, 0x5f, 0x0a, 0xeb, 0x0f, 0xde, 0xab,
+  0xd2, 0x3f, 0xfd, 0x1b, 0x4e, 0x08, 0x42, 0x54,
+  0xe1, 0x72, 0x15, 0x62, 0xf2, 0x7e, 0x79, 0x67,
+  0x2f, 0x05, 0xe3, 0xa7, 0xab, 0xef, 0x84, 0xe9,
+  0xf3, 0xc3, 0xb4, 0x51, 0xd3, 0xff, 0xc9, 0xcf,
+  0x5d, 0x40, 0x7e, 0x81, 0xcf, 0xae, 0x3a, 0x17,
+  0xaa, 0x34, 0x36, 0x69, 0xe4, 0x5a, 0x27, 0x9c,
+  0xed, 0xf4, 0xe9, 0xfb, 0x48, 0xb7, 0x6e, 0xa1,
+  0xd0, 0xe3, 0xcb, 0xd0, 0xe4, 0xeb, 0xae, 0x5e,
+  0xce, 0x9b, 0xec, 0xbd, 0x1b, 0x76, 0xcb, 0xd2,
+  0x36, 0xbd, 0x30, 0x89, 0x23, 0xf8, 0x7a, 0x1f,
+  0x2e, 0x21, 0xe2, 0x30, 0xec, 0x95, 0x27, 0x7d,
+  0x85, 0x85, 0xf7, 0x09, 0x25, 0xa1, 0x86, 0x24,
+  0x6a, 0x8c, 0x0a, 0xb2, 0xc0, 0x3d, 0x17, 0xa5,
+  0x34, 0x94, 0x7d, 0xa9, 0xd7, 0x9b, 0x9f, 0xd7,
+  0xe1, 0xf3, 0xce, 0x11, 0xb7, 0x84, 0x53, 0xff,
+  0xac, 0xaf, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x14,
+  0x54, 0xfe, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0xe8,
   0x9f, 0xfa, 0xde, 0xeb, 0x60, 0xb7, 0xfb, 0x1a,
-  0x23, 0x99, 0xff, 0xd6, 0x57, 0xba, 0xd8, 0x2d,
-  0xfe, 0xc6, 0x89, 0xca, 0x7f, 0x5b, 0x05, 0xbf,
-  0xd8, 0xd1, 0x66, 0x4f, 0xeb, 0x60, 0xb7, 0xfb,
-  0x1a, 0x2d, 0xd9, 0xff, 0xd6, 0x57, 0xba, 0xd8,
-  0x2d, 0xfe, 0xc6, 0x8a, 0x42, 0x7f, 0xeb, 0x7b,
-  0xad, 0x82, 0xdf, 0xec, 0x68, 0x94, 0xa1, 0xe4,
-  0xec, 0x96, 0x4c, 0x52, 0x97, 0x4e, 0xf4, 0x77,
-  0x70, 0xa5, 0x3f, 0xef, 0x75, 0xb0, 0x5b, 0xfd,
-  0x8d, 0x13, 0xb4, 0xff, 0xfb, 0x7c, 0x5e, 0xa4,
-  0xb8, 0xfe, 0x3a, 0x9d, 0xc6, 0x3a, 0x65, 0x59,
-  0x48, 0x9f, 0xf4, 0x69, 0xf0, 0xb7, 0xfb, 0x1a,
-  0x22, 0xc9, 0xff, 0x7b, 0xad, 0x82, 0xdf, 0xec,
-  0x68, 0x97, 0x67, 0xff, 0xec, 0xe2, 0x88, 0x0d,
-  0xb5, 0xdf, 0xe6, 0xb5, 0x4e, 0x4a, 0x95, 0xb1,
-  0x1a, 0x8a, 0x30, 0x5f, 0x46, 0x9f, 0xfd, 0x65,
-  0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68, 0x98, 0xa7,
-  0xf5, 0xb0, 0x5b, 0xfd, 0x8d, 0x15, 0x4c, 0xff,
-  0xeb, 0x2b, 0xdd, 0x6c, 0x16, 0xff, 0x63, 0x44,
-  0xe9, 0x3f, 0xb7, 0xe2, 0x8e, 0xf5, 0xc7, 0x4f,
-  0x96, 0x45, 0x92, 0xa7, 0x4f, 0xc1, 0xcd, 0xae,
-  0xce, 0x9d, 0x3d, 0xba, 0x25, 0xb6, 0x7a, 0xd5,
-  0x28, 0x9f, 0xfa, 0xfa, 0xe9, 0x1f, 0xb5, 0xeb,
-  0x6d, 0x47, 0x42, 0x91, 0x05, 0x43, 0x99, 0xff,
-  0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68, 0x9d, 0xe7,
-  0xda, 0xbf, 0xd5, 0xb2, 0xa5, 0x6e, 0x13, 0x9b,
-  0xc8, 0xc2, 0x94, 0x47, 0xe8, 0xd3, 0xff, 0xac,
-  0xaf, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x14, 0x2c,
-  0xff, 0xeb, 0x2b, 0xdd, 0x6c, 0x16, 0xff, 0x63,
-  0x45, 0x25, 0x3f, 0xff, 0xb2, 0xb6, 0x07, 0x16,
-  0xa7, 0xab, 0x54, 0x4d, 0x5e, 0xa3, 0xa1, 0xe5,
-  0xc0, 0x27, 0x1c, 0x32, 0x90, 0x9d, 0xaa, 0x3e,
-  0xde, 0x52, 0x6f, 0x52, 0x5f, 0x52, 0x9f, 0xd6,
-  0xc1, 0x6f, 0xf6, 0x34, 0x44, 0x93, 0xff, 0xac,
-  0xaf, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x12, 0xf4,
-  0xf8, 0x5b, 0xfd, 0x8d, 0x14, 0xbc, 0xfe, 0x4e,
-  0x2e, 0x36, 0xa4, 0xa9, 0xd2, 0xb6, 0x1f, 0x36,
-  0x8c, 0x27, 0xf5, 0xb0, 0x5b, 0xfd, 0x8d, 0x14,
-  0xe4, 0xff, 0xb6, 0x3f, 0x5a, 0x66, 0x75, 0x8e,
-  0x9f, 0xf6, 0x51, 0x07, 0x2c, 0x10, 0x84, 0xa9,
-  0xb6, 0x13, 0xa6, 0x7a, 0xdc, 0x22, 0x35, 0x7c,
-  0xee, 0xe0, 0xf2, 0x7c, 0x2d, 0xfe, 0xc6, 0x8a,
-  0xf2, 0x7f, 0xfe, 0xce, 0x28, 0x80, 0xdb, 0x5d,
-  0xfe, 0x6b, 0x54, 0xe4, 0xa9, 0x5b, 0x11, 0x1c,
-  0xbe, 0x61, 0x3f, 0xf5, 0xbd, 0xd6, 0xc1, 0x6f,
-  0xf6, 0x34, 0x48, 0xf3, 0xb7, 0xca, 0x1d, 0x39,
-  0xb1, 0x45, 0x58, 0xbc, 0x9f, 0x0b, 0x7f, 0xb1,
-  0xa2, 0x48, 0x9e, 0xb7, 0xba, 0xc8, 0x7b, 0x38,
-  0x53, 0x3f, 0xf5, 0xbd, 0xd6, 0xc1, 0x6f, 0xf6,
-  0x34, 0x49, 0x53, 0xe1, 0x6f, 0xf6, 0x34, 0x5e,
-  0x33, 0xf5, 0xfd, 0x7f, 0xdf, 0xa9, 0xd3, 0xea,
-  0xd7, 0x58, 0xc7, 0x4f, 0xf3, 0xad, 0x82, 0xdf,
-  0xec, 0x68, 0x93, 0x65, 0x6c, 0x46, 0x3b, 0xe6,
-  0x02, 0x61, 0xe4, 0xd0, 0x8b, 0xa5, 0x6f, 0x1d,
-  0xba, 0x17, 0x1c, 0x13, 0xee, 0x19, 0x0b, 0x43,
-  0x49, 0x45, 0x74, 0x86, 0x0e, 0x8d, 0xef, 0x8c,
-  0x4e, 0x12, 0x33, 0xea, 0x07, 0xa3, 0x9f, 0x74,
-  0x79, 0x3c, 0x47, 0xb5, 0x96, 0xd9, 0xfa, 0xec,
-  0xa5, 0x76, 0xaf, 0x4d, 0x9f, 0x9e, 0x0b, 0xdc,
-  0xe6, 0x2d, 0xce, 0x3b, 0x05, 0xa9, 0x63, 0xa3,
-  0x3f, 0x70, 0xab, 0xee, 0x55, 0xa4, 0xed, 0x2f,
-  0xd3, 0x65, 0xb9, 0x95, 0x64, 0xbd, 0x42, 0xc3,
-  0xb3, 0xb5, 0x75, 0xa4, 0x43, 0x6a, 0xb6, 0xcd,
-  0xbe, 0x93, 0xce, 0xba, 0x3d, 0x70, 0xc7, 0xf8,
-  0xbf, 0x0f, 0xc0, 0x67, 0x41, 0x2e, 0x27, 0x6a,
-  0x60,
+  0x24, 0xb9, 0xfd, 0x6c, 0x16, 0xff, 0x63, 0x45,
+  0xe5, 0x08, 0xde, 0x3b, 0xbc, 0x4e, 0xe3, 0xbc,
+  0x3b, 0x65, 0x25, 0x8e, 0xd4, 0x77, 0x58, 0x62,
+  0xf6, 0xb7, 0x8e, 0xa4, 0x75, 0x7a, 0x52, 0xb8,
+  0xed, 0x72, 0x64, 0xff, 0xeb, 0x2b, 0xdd, 0x6c,
+  0x16, 0xff, 0x63, 0x44, 0xb3, 0x3c, 0xdf, 0xec,
+  0x68, 0x8c, 0xe7, 0xed, 0xa2, 0x9e, 0xc0, 0x9d,
+  0x37, 0x5c, 0x74, 0x94, 0x74, 0xfb, 0x63, 0x5f,
+  0xb0, 0x9e, 0x9a, 0x8b, 0x79, 0x8b, 0x4f, 0xde,
+  0xed, 0x8f, 0x89, 0xd3, 0xa8, 0x8f, 0x9d, 0x02,
+  0x98, 0x82, 0x9f, 0xba, 0x99, 0xa2, 0xa9, 0xff,
+  0xb5, 0xb1, 0xf0, 0x72, 0x7d, 0xc8, 0xa3, 0xa7,
+  0xdd, 0x47, 0x53, 0xce, 0x8d, 0x9f, 0x62, 0xe4,
+  0x69, 0xff, 0xb1, 0x5a, 0xd8, 0x68, 0x95, 0xfb,
+  0xd9, 0xd3, 0xfe, 0xaa, 0x6e, 0xbb, 0x4e, 0xad,
+  0x71, 0xd2, 0xb6, 0x26, 0xa8, 0xb4, 0x2a, 0x7a,
+  0x49, 0x44, 0x79, 0xff, 0xd6, 0x57, 0xba, 0xd8,
+  0x2d, 0xfe, 0xc6, 0x89, 0xa6, 0x7f, 0xf5, 0x95,
+  0xee, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x71, 0x9f,
+  0xfd, 0x65, 0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68,
+  0xa0, 0x67, 0xc2, 0xdf, 0xec, 0x68, 0xb8, 0x26,
+  0x4d, 0x9d, 0x3f, 0xba, 0xe4, 0xdf, 0x18, 0xa3,
+  0xa5, 0x6c, 0x3f, 0x8a, 0x98, 0x5c, 0x2b, 0x3f,
+  0xb7, 0x6e, 0x68, 0x0c, 0x09, 0xd3, 0xfc, 0xeb,
+  0x60, 0xb7, 0xfb, 0x1a, 0x24, 0x99, 0x5a, 0xa7,
+  0xeb, 0xe6, 0x90, 0xf2, 0xe9, 0xf3, 0xa5, 0x5b,
+  0x32, 0x4a, 0xca, 0x40, 0x52, 0xa4, 0x32, 0xb5,
+  0x0a, 0xa9, 0xff, 0x5f, 0xfb, 0x60, 0xb7, 0xfb,
+  0x1a, 0x2d, 0x49, 0xff, 0x7b, 0xad, 0x82, 0xdf,
+  0xec, 0x68, 0x95, 0x60, 0xe9, 0x5a, 0xfa, 0x26,
+  0x14, 0x91, 0x78, 0x8d, 0x3f, 0xad, 0x82, 0xdf,
+  0xec, 0x68, 0x8a, 0x67, 0xf5, 0xb0, 0x5b, 0xfd,
+  0x8d, 0x11, 0xa4, 0xfe, 0xb6, 0x0b, 0x7f, 0xb1,
+  0xa2, 0x9f, 0x9f, 0xfd, 0x65, 0x7b, 0xad, 0x82,
+  0xdf, 0xec, 0x68, 0x9a, 0xa7, 0xf5, 0xb0, 0x5b,
+  0xfd, 0x8d, 0x15, 0xdc, 0xf3, 0x7f, 0xb1, 0xa2,
+  0xbe, 0x9c, 0x10, 0x84, 0xa9, 0x74, 0xab, 0x17,
+  0x90, 0x27, 0xcc, 0xa4, 0x79, 0xce, 0x47, 0xce,
+  0x9f, 0xf6, 0x54, 0x3f, 0xaa, 0x26, 0x3c, 0x74,
+  0xff, 0xbf, 0x63, 0x8f, 0x6d, 0xd9, 0xc1, 0xd2,
+  0xb6, 0x22, 0xe1, 0x62, 0x1e, 0x8e, 0x50, 0xf6,
+  0x7f, 0xf5, 0x95, 0xee, 0xb6, 0x0b, 0x7f, 0xb1,
+  0xa2, 0x7b, 0x9f, 0xd6, 0xc1, 0x6f, 0xf6, 0x34,
+  0x5c, 0x33, 0xff, 0x5b, 0xdd, 0x6c, 0x16, 0xff,
+  0x63, 0x44, 0x9f, 0x08, 0xae, 0xcd, 0xe3, 0xb7,
+  0x1d, 0xdf, 0x3b, 0x63, 0xb5, 0x94, 0x86, 0x35,
+  0x9a, 0xa1, 0xd1, 0x49, 0x71, 0xdc, 0xfe, 0xb6,
+  0x0b, 0x7f, 0xb1, 0xa2, 0x2a, 0x9f, 0xd6, 0xc1,
+  0x6f, 0xf6, 0x34, 0x53, 0x33, 0xff, 0xac, 0xaf,
+  0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x13, 0x3c, 0xff,
+  0xeb, 0x2b, 0xdd, 0x6c, 0x16, 0xff, 0x63, 0x45,
+  0x1b, 0x0f, 0x26, 0x35, 0xc1, 0xdd, 0xf3, 0xbd,
+  0x29, 0x4f, 0xfd, 0x6f, 0x75, 0xb0, 0x5b, 0xfd,
+  0x8d, 0x11, 0xd4, 0xfd, 0xbc, 0xef, 0x18, 0xf1,
+  0xd3, 0xe1, 0x6f, 0xf6, 0x34, 0x53, 0x53, 0xf6,
+  0xd1, 0x4f, 0x60, 0x4e, 0x9f, 0xfe, 0xcd, 0x57,
+  0x1c, 0x3f, 0xdd, 0x57, 0xdc, 0x74, 0xc8, 0x03,
+  0xa7, 0xfa, 0x9e, 0xfa, 0x36, 0xda, 0xc2, 0x88,
+  0xfe, 0x96, 0xf3, 0x4d, 0x95, 0xb8, 0x4d, 0x2f,
+  0x0b, 0xb5, 0x0b, 0xf9, 0xf0, 0xb7, 0xfb, 0x1a,
+  0x2a, 0xa9, 0xff, 0x7b, 0xad, 0x82, 0xdf, 0xec,
+  0x68, 0x9b, 0x65, 0x6c, 0x3f, 0x65, 0x18, 0x4f,
+  0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x2b, 0xf9, 0xfd,
+  0x6c, 0x16, 0xff, 0x63, 0x45, 0x8d, 0x3e, 0x16,
+  0xff, 0x63, 0x45, 0xab, 0x3f, 0xef, 0x75, 0xb0,
+  0x5b, 0xfd, 0x8d, 0x14, 0x14, 0xad, 0x87, 0xec,
+  0xa3, 0x09, 0xfd, 0x6c, 0x16, 0xff, 0x63, 0x45,
+  0xc5, 0x3f, 0xad, 0x82, 0xdf, 0xec, 0x68, 0xba,
+  0x67, 0xff, 0xdd, 0xfb, 0x69, 0xd8, 0x23, 0xee,
+  0x7b, 0x02, 0x74, 0xfd, 0x7a, 0xf7, 0x2b, 0xfa,
+  0x3a, 0x79, 0xbf, 0xd8, 0xd1, 0x26, 0x4f, 0xf0,
+  0xe3, 0xfa, 0xd7, 0xba, 0x87, 0x40, 0x9f, 0x1a,
+  0x8a, 0xe7, 0xee, 0x01, 0x7a, 0xd0, 0x0b, 0xe7,
+  0x4f, 0xb3, 0x5b, 0x57, 0x9d, 0x3f, 0xfe, 0xf6,
+  0x14, 0xaf, 0x73, 0x59, 0x60, 0x84, 0x25, 0x43,
+  0x8f, 0xe3, 0x44, 0xd3, 0xff, 0xae, 0xef, 0xe9,
+  0x06, 0x95, 0x4e, 0xe8, 0xe9, 0xc1, 0x08, 0x4a,
+  0x9f, 0x87, 0xde, 0x56, 0xe8, 0x55, 0x8b, 0xc9,
+  0xf6, 0x28, 0x72, 0xf6, 0x74, 0xff, 0x94, 0x8d,
+  0x5e, 0xdd, 0xa4, 0xa1, 0xd3, 0xfd, 0x9e, 0x0e,
+  0x59, 0xc7, 0xb8, 0xe9, 0xff, 0xde, 0xf5, 0x76,
+  0x9d, 0xc5, 0xb6, 0x3b, 0x3a, 0x31, 0x18, 0x3a,
+  0x3e, 0x09, 0xcc, 0xfd, 0x7b, 0xee, 0x57, 0xf4,
+  0x74, 0xf6, 0x9e, 0xce, 0x0e, 0x9f, 0xed, 0xdf,
+  0xe6, 0x20, 0x56, 0xe8, 0x74, 0x2c, 0x7c, 0x0b,
+  0xe4, 0x73, 0x82, 0x10, 0x9d, 0x3f, 0xfe, 0xc5,
+  0x6b, 0xa8, 0x0c, 0xe2, 0x98, 0xa4, 0x62, 0xac,
+  0x5e, 0x46, 0x26, 0x69, 0xb8, 0x48, 0x55, 0x0a,
+  0x7f, 0x08, 0xf8, 0xf5, 0x1c, 0x74, 0xce, 0xb2,
+  0xf1, 0x73, 0x63, 0x21, 0x29, 0x7c, 0x85, 0xf8,
+  0x57, 0xac, 0x45, 0xec, 0xbd, 0x3c, 0xa4, 0x3a,
+  0xb5, 0x1b, 0x1f, 0x33, 0x59, 0xf6, 0x28, 0x72,
+  0xf6, 0x74, 0xff, 0xd9, 0x5e, 0xa3, 0xdc, 0xeb,
+  0x5f, 0xbd, 0x9d, 0x3f, 0x7b, 0x58, 0x21, 0x09,
+  0xd2, 0xb3, 0x2f, 0x40, 0xfc, 0xe9, 0x5f, 0x61,
+  0x6f, 0x42, 0x95, 0xc9, 0x50, 0xe6, 0x56, 0xd7,
+  0x11, 0xcb, 0xbf, 0x0b, 0x21, 0x27, 0x51, 0xd8,
+  0x21, 0x63, 0x42, 0x7d, 0x1d, 0xdd, 0x3d, 0x79,
+  0x3f, 0xad, 0x82, 0xdf, 0xec, 0x68, 0x8d, 0x67,
+  0xc2, 0xdf, 0xec, 0x68, 0xa9, 0x66, 0xf6, 0x34,
+  0x43, 0x52, 0xb6, 0x1e, 0x8f, 0x98, 0x4f, 0xfd,
+  0x6f, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x11, 0xf4,
+  0xfe, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0xc7, 0x9f,
+  0xaf, 0x5e, 0xe5, 0x7f, 0x47, 0x4f, 0xf7, 0x7c,
+  0x14, 0xfd, 0x6b, 0xce, 0x9e, 0x02, 0xb6, 0x27,
+  0x4f, 0xff, 0xf2, 0x0f, 0x73, 0x8c, 0xad, 0x76,
+  0xd5, 0xde, 0xa9, 0xef, 0x9d, 0x1b, 0x44, 0x3d,
+  0x48, 0x67, 0xc2, 0xdf, 0xec, 0x68, 0xb4, 0x27,
+  0xe5, 0xdc, 0xf5, 0xd4, 0x01, 0xd3, 0xe4, 0xd6,
+  0x55, 0x0e, 0x9f, 0xfe, 0xcd, 0x53, 0x16, 0xaa,
+  0x2e, 0xca, 0xd5, 0x0e, 0x87, 0x8f, 0xd7, 0xa4,
+  0xb0, 0x88, 0xc9, 0xc8, 0x53, 0x4f, 0xf7, 0x73,
+  0x35, 0x5f, 0xed, 0xf3, 0xa7, 0xf6, 0x55, 0x6d,
+  0xd7, 0x6a, 0x3a, 0x7f, 0x3b, 0x06, 0x9d, 0x47,
+  0x8e, 0x9f, 0xec, 0xc0, 0xe3, 0x36, 0x04, 0xe8,
+  0xc4, 0x4d, 0x3e, 0x69, 0x43, 0x29, 0xec, 0xaf,
+  0xe8, 0xe9, 0xfd, 0x7f, 0x7d, 0xb9, 0xd9, 0x43,
+  0xa5, 0x65, 0xe2, 0xb8, 0xa4, 0x31, 0xe2, 0x17,
+  0xd8, 0x47, 0x58, 0x7c, 0xd0, 0x9b, 0x50, 0xd3,
+  0x5f, 0x30, 0xe6, 0x41, 0x3f, 0x5e, 0x6f, 0x8e,
+  0xa2, 0xc7, 0x4f, 0x65, 0x7f, 0x47, 0x4a, 0xf5,
+  0xc3, 0xd2, 0xe9, 0x94, 0xf8, 0x5b, 0xfd, 0x8d,
+  0x16, 0xb4, 0xff, 0xbd, 0xd6, 0xc1, 0x6f, 0xf6,
+  0x34, 0x50, 0x72, 0xb2, 0xf1, 0x14, 0x58, 0x58,
+  0xa3, 0x09, 0xff, 0xd6, 0x57, 0xba, 0xd8, 0x2d,
+  0xfe, 0xc6, 0x8a, 0x2e, 0x7f, 0x5b, 0x05, 0xbf,
+  0xd8, 0xd1, 0x75, 0x43, 0x97, 0xc6, 0x9a, 0x11,
+  0x9b, 0x26, 0x52, 0x65, 0x65, 0xe2, 0x82, 0x39,
+  0x1a, 0x1c, 0xe9, 0x4a, 0x7c, 0x2d, 0xfe, 0xc6,
+  0x88, 0x86, 0x75, 0x73, 0x83, 0xa5, 0x6c, 0x3c,
+  0xc7, 0xcc, 0x27, 0xf5, 0xb0, 0x5b, 0xfd, 0x8d,
+  0x11, 0xb4, 0xfe, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2,
+  0x9b, 0x9f, 0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x54,
+  0x13, 0xfa, 0xd8, 0x2d, 0xfe, 0xc6, 0x8a, 0x9a,
+  0x7c, 0x2d, 0xfe, 0xc6, 0x8a, 0xc2, 0x7d, 0xb0,
+  0xf1, 0x70, 0x9d, 0x3f, 0xce, 0xb6, 0x0b, 0x7f,
+  0xb1, 0xa2, 0x3f, 0x9d, 0x88, 0xf1, 0xd2, 0xb6,
+  0x22, 0xd5, 0x8c, 0x3c, 0xa7, 0xa8, 0x33, 0xff,
+  0xac, 0xaf, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x13,
+  0x7c, 0xff, 0xca, 0xf7, 0x5b, 0x05, 0xbf, 0xd8,
+  0xd1, 0x3f, 0x4f, 0xd7, 0xa1, 0x7a, 0xde, 0xab,
+  0xf8, 0xf9, 0xd3, 0xff, 0xc8, 0x88, 0x88, 0x88,
+  0x88, 0x8f, 0xd0, 0xe9, 0xf0, 0xed, 0xef, 0x51,
+  0x53, 0x04, 0x25, 0x46, 0x1b, 0xd0, 0x93, 0xca,
+  0xe2, 0xac, 0x68, 0x21, 0x11, 0x8f, 0x48, 0x53,
+  0x4f, 0xc3, 0xed, 0x5d, 0x89, 0xd3, 0xcf, 0x2b,
+  0x6e, 0x3a, 0x7f, 0x55, 0x15, 0x60, 0x01, 0x0e,
+  0x90, 0xa1, 0xea, 0xec, 0x8e, 0x70, 0x29, 0x87,
+  0x4f, 0x53, 0x5b, 0x58, 0xe8, 0x44, 0xc2, 0xb6,
+  0x4e, 0x2f, 0xfd, 0x26, 0xd0, 0xdc, 0xf7, 0xad,
+  0xcd, 0x47, 0x4d, 0xfd, 0x3a, 0x04, 0xdc, 0xa8,
+  0x92, 0x70, 0x42, 0x13, 0xa7, 0x9e, 0xee, 0xd0,
+  0xab, 0x17, 0x93, 0xcf, 0xeb, 0x6c, 0x74, 0x22,
+  0x23, 0xea, 0x79, 0x71, 0x8c, 0xff, 0xcf, 0x5c,
+  0x0c, 0xed, 0xcb, 0x26, 0xbc, 0xe9, 0xe4, 0xd5,
+  0x18, 0xd1, 0x07, 0x40, 0x9f, 0xa6, 0x91, 0xe6,
+  0x1e, 0x0e, 0x98, 0x21, 0x3a, 0x1c, 0x6b, 0x02,
+  0x2d, 0x3d, 0x44, 0xda, 0xe2, 0xac, 0x68, 0x67,
+  0xd4, 0xe7, 0xc0, 0x28, 0x74, 0x6c, 0xf7, 0xb9,
+  0x99, 0xce, 0x08, 0x42, 0x54, 0x15, 0x62, 0xf2,
+  0x7b, 0x61, 0xda, 0xc5, 0x43, 0x1b, 0xcd, 0x8c,
+  0xc6, 0xd3, 0x68, 0xac, 0x33, 0x3a, 0xf9, 0x3d,
+  0xc7, 0xf4, 0x07, 0x4f, 0xfc, 0x9d, 0x07, 0x51,
+  0xf5, 0x93, 0xa0, 0x3a, 0x00, 0x7c, 0xf4, 0x22,
+  0x9f, 0x96, 0x4c, 0x1a, 0xec, 0xe9, 0xfb, 0x58,
+  0xb7, 0x51, 0x47, 0x88, 0x0a, 0x7d, 0xfd, 0xe2,
+  0xa8, 0x68, 0x80, 0xac, 0x6e, 0xa7, 0xc8, 0x0d,
+  0xbf, 0x43, 0xa7, 0xf0, 0xad, 0x4d, 0xf7, 0x5b,
+  0x3a, 0x79, 0xf0, 0x0a, 0x15, 0x30, 0x42, 0x54,
+  0x21, 0xb7, 0x09, 0x0c, 0xfd, 0xe2, 0xe7, 0x77,
+  0x65, 0x58, 0xd0, 0x42, 0x27, 0x77, 0x84, 0x5b,
+  0x66, 0xea, 0x26, 0x8a, 0x2e, 0x84, 0x5c, 0xfa,
+  0xed, 0x5d, 0xfc, 0xcd, 0x10, 0x3c, 0xff, 0xab,
+  0x73, 0xc9, 0xc9, 0x34, 0x9c, 0x1d, 0x3b, 0xc5,
+  0xe3, 0xa6, 0x08, 0x4e, 0x9f, 0xc3, 0xbc, 0x5d,
+  0xcd, 0xd6, 0x63, 0x62, 0x11, 0xb9, 0x27, 0x08,
+  0xbf, 0x17, 0x39, 0xff, 0xd8, 0xa5, 0x7b, 0xb0,
+  0x5b, 0xfd, 0x8d, 0x10, 0xc4, 0x54, 0xfe, 0x7a,
+  0x51, 0x3f, 0x60, 0xb7, 0xfb, 0x1a, 0x20, 0xa9,
+  0xed, 0x51, 0x00, 0x54, 0xef, 0x17, 0x8a, 0x9e,
+  0xbb, 0xbf, 0x7c, 0xa9, 0xfd, 0xb7, 0xb3, 0x54,
+  0x40, 0x15, 0x05, 0x4f, 0xd8, 0xc9, 0x54, 0x51,
+  0x53, 0x04, 0x25, 0x4f, 0xdd, 0x4e, 0xbd, 0xb1,
+  0x2a, 0x31, 0x30, 0xa6, 0x21, 0x50, 0xdd, 0x49,
+  0x00, 0x67, 0xd0, 0xa0, 0x95, 0x73, 0x16, 0x9b,
+  0x62, 0x55, 0x8f, 0xca, 0x5e, 0xe4, 0xf5, 0xeb,
+  0x1d, 0x8c, 0xff, 0x91, 0xdf, 0xdc, 0xa0, 0xa5,
+  0x0e, 0x9f, 0xf2, 0x6a, 0xa8, 0xbb, 0x84, 0x02,
+  0x1d, 0x3f, 0xff, 0x2d, 0xfe, 0xef, 0xaf, 0x2c,
+  0x7a, 0xed, 0x5d, 0xfc, 0xcd, 0x17, 0xdc, 0xfb,
+  0x7a, 0xee, 0x38, 0xe9, 0xff, 0x77, 0x6e, 0xd5,
+  0x70, 0x77, 0x43, 0xa7, 0xf6, 0x81, 0xcf, 0xae,
+  0xae, 0x1e, 0x20, 0x19, 0xde, 0x2e, 0x3c, 0x40,
+  0x31, 0x87, 0xd3, 0x72, 0x14, 0xde, 0xe3, 0xc4,
+  0x03, 0x3d, 0xfd, 0x7d, 0xc7, 0x88, 0x06, 0x7f,
+  0x6d, 0xab, 0x80, 0x02, 0x1e, 0x20, 0x19, 0xdb,
+  0xef, 0x07, 0x88, 0x06, 0x38, 0x45, 0xca, 0x88,
+  0xaa, 0x5e, 0xb8, 0xfa, 0x70, 0xa6, 0x8f, 0x10,
+  0x0c, 0x1e, 0x20, 0x19, 0x91, 0x47, 0x88, 0x06,
+  0x38, 0x37, 0x3b, 0x17, 0x9e, 0xda, 0xb8, 0x43,
+  0xc4, 0x03, 0x3b, 0x5e, 0xc7, 0x88, 0x06, 0x7f,
+  0xdd, 0xf7, 0x5a, 0xbb, 0x6f, 0x13, 0xc4, 0x03,
+  0x37, 0xf0, 0x78, 0x80, 0x67, 0xf7, 0x7c, 0x34,
+  0xa2, 0x00, 0xf1, 0x00, 0xcf, 0xb7, 0x7f, 0xfa,
+  0x03, 0xc4, 0x03, 0x36, 0xe8, 0x78, 0x80, 0x60,
+  0x4f, 0x67, 0x46, 0xd3, 0xed, 0x75, 0x1f, 0x71,
+  0xa2, 0x01, 0x98, 0x08, 0x78, 0x80, 0x6c, 0x6d,
+  0x67, 0xdb, 0x45, 0x7f, 0x07, 0x88, 0x06, 0x7a,
+  0xef, 0xeb, 0x1e, 0x20, 0x19, 0xc8, 0x2c, 0x78,
+  0x80, 0x67, 0xfd, 0x8f, 0xd3, 0x84, 0xce, 0x82,
+  0x87, 0x88, 0x06, 0x7d, 0x77, 0xb9, 0xc8, 0x78,
+  0x80, 0x63, 0x11, 0x01, 0x54, 0xc9, 0x84, 0x07,
+  0x88, 0x06, 0x1c, 0xaa, 0x3f, 0x82, 0x3c, 0x84,
+  0xc6, 0xd5, 0xaa, 0x64, 0x03, 0x4a, 0x17, 0x6a,
+  0x14, 0xd7, 0x11, 0x4f, 0xb3, 0x54, 0xf7, 0xcf,
+  0x10, 0x0c, 0xfe, 0xe1, 0x19, 0x61, 0x4d, 0x1e,
+  0x20, 0x1e, 0x0d, 0xa4, 0xe1, 0x40, 0x9e, 0x20,
+  0x18, 0x63, 0xf7, 0x15, 0x09, 0xed, 0xf5, 0xd4,
+  0x3c, 0x40, 0x33, 0xf7, 0xac, 0xec, 0x7d, 0xc7,
+  0x88, 0x06, 0x31, 0x11, 0x40, 0x20, 0xb8, 0xbe,
+  0x7f, 0xf7, 0xbd, 0xc5, 0x52, 0x96, 0xa5, 0xc2,
+  0x03, 0xc4, 0x03, 0x30, 0x80, 0xf1, 0x00, 0xcf,
+  0xbf, 0x54, 0xdb, 0xe7, 0x88, 0x06, 0x7e, 0xdf,
+  0x6e, 0x76, 0x50, 0xf1, 0x00, 0xc2, 0x22, 0x4b,
+  0xa4, 0x5a, 0x35, 0x8e, 0x17, 0xf5, 0x72, 0x1b,
+  0x6b, 0x20, 0x0b, 0x05, 0x48, 0xbc, 0xbc, 0x04,
+  0xf4, 0x95, 0xb1, 0xa8, 0xf0, 0x17, 0xcc, 0x39,
+  0xc3, 0xae, 0x77, 0xfb, 0x1a, 0x20, 0x1b, 0x22,
+  0xda, 0x7a, 0xfd, 0xe9, 0x70, 0xa3, 0xa6, 0x02,
+  0x15, 0x2b, 0xe5, 0x4e, 0xaa, 0x3c, 0x74, 0xc1,
+  0x09, 0x51, 0xb3, 0xd9, 0xbd, 0x8a, 0xac, 0x24,
+  0x11, 0xc9, 0xca, 0xdd, 0x0a, 0xb1, 0xe0, 0xcf,
+  0x6a, 0x97, 0x97, 0x1d, 0x0f, 0x32, 0xaa, 0x9c,
+  0x4e, 0xd4, 0x93, 0x2d, 0x9c, 0x02, 0x18, 0xdc,
+  0xcb, 0x67, 0xe1, 0x59, 0xc8, 0x2f, 0x1d, 0x3f,
+  0xe7, 0x53, 0x97, 0x71, 0x48, 0x37, 0xce, 0x9f,
+  0xb9, 0x84, 0x77, 0x95, 0x2a, 0x79, 0x6a, 0xfa,
+  0xc7, 0x4f, 0xb1, 0x67, 0x23, 0xe7, 0x4f, 0x67,
+  0x51, 0xc5, 0x40, 0x9f, 0x5f, 0x48, 0xef, 0x0a,
+  0x21, 0x13, 0x38, 0xc2, 0xda, 0xa0, 0xfc, 0x26,
+  0x67, 0xb7, 0xdd, 0x50, 0xe9, 0xd7, 0x2f, 0x74,
+  0x3a, 0x7f, 0xed, 0x53, 0x38, 0x47, 0xe9, 0x8f,
+  0xe8, 0xe8, 0x43, 0xe8, 0xf2, 0x29, 0xf7, 0xae,
+  0xe3, 0x84, 0x3a, 0x6a, 0x50, 0xe9, 0xc1, 0x08,
+  0x4e, 0x98, 0x1e, 0x55, 0x8b, 0xc8, 0x13, 0xd6,
+  0xa1, 0x94, 0xef, 0x06, 0x15, 0x0e, 0x45, 0xda,
+  0xa1, 0x00, 0xbe, 0x43, 0x3f, 0xb5, 0xdc, 0x7c,
+  0x1c, 0xdc, 0x74, 0xff, 0x77, 0x17, 0x65, 0x82,
+  0x10, 0x95, 0x39, 0x5f, 0xa3, 0xa2, 0xa7, 0xaa,
+  0xb8, 0xea, 0x11, 0x1c, 0xfb, 0x38, 0xf8, 0x45,
+  0xcd, 0x5f, 0x3a, 0x65, 0xa8, 0x74, 0xfd, 0x6c,
+  0x5d, 0xbe, 0xf1, 0x86, 0xb3, 0x98, 0xac, 0xf7,
+  0x19, 0x5f, 0x3a, 0x7f, 0xe4, 0xce, 0xba, 0xb9,
+  0xde, 0xa0, 0x4e, 0x96, 0xc5, 0x15, 0x7d, 0x48,
+  0xd1, 0x0c, 0x3c, 0xda, 0x4c, 0x3a, 0x37, 0x0e,
+  0x23, 0xf9, 0xbe, 0x5e, 0xc7, 0x7b, 0x3f, 0x1a,
+  0x58, 0xc5, 0x63, 0xa3, 0x02, 0x07, 0x61, 0x15,
+  0xa8, 0xf0, 0x97, 0x46, 0x15, 0x3f, 0x74, 0x19,
+  0xc7, 0xb8, 0xe9, 0xf7, 0x35, 0x9c, 0x97, 0xb2,
+  0xa3, 0x0f, 0x6f, 0x99, 0x6c, 0xff, 0xe1, 0xbf,
+  0xdb, 0xbf, 0x9e, 0x53, 0x69, 0xd3, 0xa5, 0xcc,
+  0xd1, 0x02, 0xcb, 0x46, 0xa0, 0x52, 0x5b, 0xd1,
+  0xbc, 0x08, 0xfc, 0xff, 0xb6, 0xbf, 0x5d, 0xf3,
+  0xb0, 0x00, 0x85, 0x4f, 0xfe, 0xd5, 0x3d, 0xfe,
+  0x4a, 0x4c, 0xee, 0x97, 0xce, 0x84, 0x44, 0x9e,
+  0xd1, 0x27, 0x3d, 0xd7, 0x1d, 0x08, 0x9c, 0x12,
+  0xa1, 0x13, 0x58, 0x5d, 0x5c, 0x45, 0x3f, 0x9c,
+  0xb6, 0x77, 0xeb, 0x87, 0x4f, 0xfe, 0x16, 0xee,
+  0x2e, 0xee, 0x20, 0xa5, 0x0e, 0x9f, 0xde, 0xb5,
+  0x71, 0x59, 0x43, 0xa3, 0x0f, 0xe5, 0x72, 0x3c,
+  0xff, 0xfc, 0x81, 0xa6, 0x9f, 0x6d, 0xd7, 0x95,
+  0xe6, 0x57, 0x6a, 0x3a, 0x36, 0x88, 0x4d, 0x11,
+  0xce, 0xe3, 0xc4, 0xe9, 0xf0, 0x3f, 0xb9, 0x78,
+  0x74, 0x21, 0xe2, 0x5c, 0x37, 0x3c, 0x8a, 0x7d,
+  0x63, 0xa1, 0x13, 0xdb, 0x74, 0x65, 0xf4, 0x67,
+  0xd1, 0x14, 0xf0, 0x3d, 0xfa, 0x1d, 0x30, 0x42,
+  0x74, 0x50, 0xdc, 0x04, 0x8a, 0x7e, 0xa6, 0xeb,
+  0xf9, 0x52, 0xac, 0x68, 0x67, 0x04, 0x21, 0x2a,
+  0x79, 0xda, 0xc6, 0x2a, 0xc5, 0xe4, 0xfb, 0x38,
+  0xd8, 0x28, 0x74, 0xbc, 0x4f, 0x5f, 0xa5, 0xf3,
+  0xf7, 0x5f, 0xa2, 0xd9, 0xa3, 0xa7, 0xcf, 0x5e,
+  0xf7, 0x8f, 0x9d, 0x3f, 0xec, 0x6e, 0x30, 0x43,
+  0xf5, 0x58, 0xe9, 0x9c, 0xf1, 0x50, 0xf9, 0xea,
+  0x74, 0xf6, 0x05, 0x14, 0x9f, 0x08, 0x18, 0x44,
+  0xc7, 0xf0, 0x9b, 0xe1, 0xa7, 0x3f, 0xeb, 0xe8,
+  0xff, 0x52, 0xb5, 0xb9, 0x8e, 0x9f, 0xbb, 0xf7,
+  0xeb, 0xee, 0x3a, 0x70, 0x42, 0x12, 0xa7, 0x73,
+  0x40, 0x15, 0x62, 0xf2, 0x7f, 0xbb, 0xe0, 0xe4,
+  0xe4, 0x03, 0xe7, 0x47, 0x08, 0xf2, 0x52, 0x08,
+  0x12, 0xb4, 0x59, 0x38, 0x21, 0x09, 0x62, 0x10,
+  0x9f, 0x0b, 0x7f, 0xb1, 0x62, 0x10, 0xb1, 0xa9,
+  0x9c, 0x10, 0x84, 0xb1, 0x07, 0xc1, 0x62, 0x0f,
+  0xb1, 0xa9, 0x99, 0x15, 0x88, 0x90, 0x66, 0x99,
+  0xf6, 0x93, 0x48, 0xa3, 0xa7, 0xbb, 0xb4, 0xbe,
+  0x74, 0xee, 0x68, 0x03, 0xa1, 0xe3, 0xc0, 0x51,
+  0x1c, 0xf9, 0x92, 0xa8, 0xa2, 0xa7, 0xdd, 0xfe,
+  0xf7, 0x0a, 0x9b, 0x18, 0xa9, 0x82, 0x12, 0xa3,
+  0x0f, 0xd6, 0x84, 0xba, 0x26, 0x08, 0xa4, 0xfe,
+  0xef, 0x34, 0x05, 0x72, 0xf0, 0xab, 0x1b, 0xb8,
+  0x44, 0xe0, 0x36, 0xcd, 0xf0, 0xd3, 0x9f, 0xfd,
+  0x54, 0x05, 0x33, 0x38, 0xfe, 0xfd, 0xf3, 0xa7,
+  0xf5, 0x39, 0xaa, 0x81, 0xf7, 0xce, 0x84, 0x56,
+  0xaf, 0xb8, 0x7b, 0x8c, 0x75, 0x9e, 0x69, 0x44,
+  0xa9, 0xc1, 0x08, 0x4a, 0x9f, 0x38, 0x1f, 0xde,
+  0x0a, 0xb1, 0x79, 0x3f, 0xfd, 0xd7, 0xf9, 0x3e,
+  0x04, 0xeb, 0x7b, 0xdd, 0xf3, 0xa7, 0xff, 0xce,
+  0xc4, 0xb7, 0x1d, 0x4b, 0x9b, 0x2f, 0xec, 0x4e,
+  0x9e, 0xdf, 0x18, 0xa3, 0xa1, 0x13, 0x02, 0x71,
+  0xbf, 0xa9, 0xdc, 0xad, 0x3f, 0xea, 0x51, 0x07,
+  0x49, 0x6e, 0x36, 0x74, 0xff, 0xbb, 0xeb, 0x57,
+  0xc4, 0x77, 0xc1, 0xd1, 0xb3, 0xfc, 0x51, 0xf4,
+  0xfd, 0xe3, 0xc6, 0x67, 0x4e, 0x9f, 0xfe, 0xcd,
+  0x53, 0x16, 0xaa, 0x2e, 0xca, 0xd5, 0x0e, 0x9f,
+  0xda, 0xbd, 0x0b, 0x75, 0x7a, 0x3d, 0x71, 0xd1,
+  0xc2, 0x2f, 0xba, 0x57, 0xa5, 0x09, 0xff, 0xfd,
+  0xdd, 0x65, 0x76, 0x9a, 0xd8, 0x11, 0xd6, 0x08,
+  0x42, 0x54, 0xf7, 0x19, 0x97, 0xca, 0x9c, 0xee,
+  0xdc, 0x68, 0x86, 0x67, 0x04, 0x21, 0x2a, 0x76,
+  0x75, 0x8a, 0xb1, 0x79, 0x3f, 0xec, 0x7b, 0x38,
+  0xf7, 0x75, 0x1e, 0x3a, 0x00, 0x7d, 0x1d, 0x29,
+  0x84, 0x4d, 0x51, 0xe6, 0x17, 0xc8, 0xc6, 0x15,
+  0xd3, 0xdb, 0xd6, 0xd0, 0xe9, 0xfd, 0x76, 0x08,
+  0x01, 0xbe, 0x9d, 0x3f, 0xfe, 0x47, 0x6f, 0x8a,
+  0xf3, 0xa6, 0x0b, 0x7f, 0xb1, 0xa2, 0x0c, 0x8a,
+  0xa2, 0x53, 0x46, 0x73, 0xf9, 0x7f, 0x28, 0xbf,
+  0x82, 0x87, 0x43, 0x93, 0x0e, 0xdc, 0x2d, 0x74,
+  0x47, 0x3f, 0xfc, 0x9d, 0x7b, 0x92, 0xdb, 0xee,
+  0x71, 0x9d, 0xbe, 0x74, 0xe4, 0x15, 0x8e, 0x84,
+  0x5c, 0x5d, 0xc8, 0x70, 0x6e, 0x38, 0x5f, 0x8d,
+  0x46, 0xe3, 0x65, 0xf5, 0x69, 0xfd, 0xad, 0xae,
+  0xde, 0x9c, 0x85, 0x49, 0x47, 0x4f, 0xea, 0x67,
+  0x6f, 0x8a, 0x5b, 0x67, 0x8b, 0xcc, 0xd6, 0x78,
+  0x6e, 0x7d, 0xc7, 0x4f, 0xee, 0xbb, 0xb8, 0xa4,
+  0x63, 0xa7, 0x2b, 0x8c, 0x3a, 0x10, 0xfc, 0x30,
+  0x8f, 0xcc, 0x67, 0xfd, 0x76, 0xa9, 0xcc, 0x40,
+  0xad, 0xd0, 0xe9, 0xff, 0x93, 0xbf, 0x54, 0x05,
+  0x86, 0x94, 0x2a, 0x38, 0x44, 0x22, 0x90, 0xa7,
+  0xd5, 0xde, 0xdf, 0xa1, 0xd0, 0x54, 0xfd, 0x4e,
+  0x68, 0x28, 0xa2, 0xa0, 0xa8, 0x2a, 0x0a, 0x82,
+  0xa1, 0xc7, 0xbf, 0xb0, 0xa0, 0x16, 0xdc, 0x14,
+  0xbe, 0x15, 0x78, 0x15, 0x35, 0x70, 0xa9, 0xfb,
+  0xff, 0x4b, 0x22, 0x8a, 0xe4, 0x5a, 0xc9, 0x7b,
+  0x2a, 0x0a, 0x82, 0xa1, 0xc5, 0xa6, 0xc2, 0xa0,
+  0xa8, 0x2a, 0x0a, 0x82, 0xa0, 0xa8, 0x2a, 0x1e,
+  0x37, 0x9c, 0x05, 0x6c, 0x28, 0x01, 0x54, 0x0a,
+  0x5c, 0x15, 0x05, 0x41, 0x50, 0xe2, 0xd2, 0x81,
+  0x50, 0x54, 0x15, 0x05, 0x41, 0x50, 0xe3, 0x50,
+  0x00, 0xad, 0x05, 0x5e, 0x05, 0x41, 0x50, 0x54,
+  0x15, 0x05, 0x43, 0xc6, 0xa2, 0xf8, 0x50, 0x85,
+  0x54, 0x2a, 0x57, 0xca, 0x82, 0xa0, 0xa8, 0x2a,
+  0x0a, 0x8e, 0x0d, 0x43, 0xe1, 0x40, 0x0a, 0xb8,
+  0x2a, 0x0a, 0x82, 0xa0, 0xa9, 0xf5, 0x50, 0x14,
+  0xc2, 0xa0, 0xa8, 0x71, 0xe7, 0x30, 0x55, 0x42,
+  0xbc, 0x28, 0x04, 0xd2, 0x62, 0xa0, 0xa8, 0x2a,
+  0x0a, 0x82, 0xa1, 0xc6, 0xa1, 0xf0, 0xad, 0x85,
+  0x2e, 0x0a, 0x82, 0xa0, 0xa8, 0x2a, 0x0a, 0x87,
+  0x1a, 0x8e, 0x02, 0xaa, 0x15, 0xd0, 0xa9, 0x54,
+  0xa8, 0x2a, 0x0a, 0x93, 0x8a, 0x82, 0x9f, 0x2c,
+  0x20, 0xa8, 0x2a, 0x0a, 0x82, 0xa1, 0xe3, 0xe6,
+  0x70, 0x55, 0xf1, 0xa6, 0x1a, 0x58, 0x28, 0x01,
+  0x5a, 0x0a, 0x96, 0x15, 0x05, 0x41, 0x52, 0x71,
+  0x50, 0x53, 0xe5, 0x84, 0x15, 0x05, 0x42, 0x1e,
+  0x93, 0x82, 0xb6, 0x34, 0x23, 0x4a, 0x0a, 0x82,
+  0xa0, 0xa8, 0x2a, 0x0a, 0x82, 0xa1, 0x0d, 0x93,
+  0xe1, 0x42, 0x14, 0xa0, 0xae, 0x85, 0x41, 0x50,
+  0x54, 0x15, 0x02, 0x5f, 0x50, 0x2b, 0x41, 0x50,
+  0x54, 0x15, 0x05, 0x42, 0x8b, 0xee, 0x85, 0x68,
+  0x2a, 0x4a, 0x2a, 0x0a, 0x82, 0xa0, 0x05, 0xa5,
+  0xc1, 0x50, 0x54, 0x15, 0x05, 0x41, 0x50, 0x86,
+  0xa1, 0x60, 0xaa, 0x85, 0x5c, 0x15, 0x08, 0xbf,
+  0x5a, 0xf3, 0x93, 0x8f, 0x78, 0x29, 0xc5, 0xc6,
+  0x6d, 0x7d, 0x23, 0x6c, 0xd7, 0xb3, 0xd5, 0x8e,
+  0x86, 0x11, 0x8a, 0x47, 0xa9, 0xbf, 0xb3, 0x00,
+  0xf3, 0xae, 0xd4, 0x66, 0xd3, 0x0d, 0xcf, 0x2b,
+  0x99, 0x42, 0x94, 0xbe, 0x5b, 0xcc, 0x92, 0xf1,
+  0x26, 0x7c, 0xee, 0xa6, 0x50, 0xab, 0x26, 0xaf,
+  0x3b, 0x68, 0xa2, 0xa7, 0xb6, 0xde, 0x27, 0x4e,
+  0xdf, 0x18, 0x74, 0xf3, 0xe9, 0xce, 0xcf, 0xa2,
+  0x3c, 0x4e, 0x6a, 0x37, 0xa1, 0xf9, 0x80, 0x87,
+  0x4f, 0xc3, 0xfd, 0xe6, 0x80, 0x3a, 0x6f, 0x13,
+  0xa5, 0xb3, 0x98, 0xb4, 0x93, 0x1d, 0x25, 0x1d,
+  0x3b, 0x17, 0xed, 0xb4, 0x49, 0x88, 0xad, 0x50,
+  0x7c, 0x7b, 0x98, 0x7c, 0xff, 0xfa, 0xe4, 0xe5,
+  0xe2, 0x3e, 0x04, 0xb0, 0x42, 0x13, 0xa1, 0xcc,
+  0xd4, 0x9e, 0x21, 0x7b, 0xb8, 0x58, 0x2c, 0x49,
+  0xf4, 0xa1, 0xbe, 0xc3, 0xab, 0x4b, 0xd3, 0xf9,
+  0x3b, 0xaf, 0xed, 0xd8, 0x74, 0xfe, 0x17, 0x77,
+  0x6e, 0xae, 0x1d, 0x3e, 0xc0, 0x66, 0x2c, 0x74,
+  0xfd, 0x4c, 0x5d, 0xd4, 0x7c, 0xe9, 0x26, 0x22,
+  0x1f, 0xa6, 0x5a, 0x26, 0x9e, 0xbb, 0xc5, 0xc7,
+  0x4f, 0x25, 0xcb, 0xdd, 0x0a, 0x9f, 0x3a, 0xc1,
+  0x08, 0x4e, 0x8e, 0x9e, 0x7d, 0xc4, 0xf1, 0xc2,
+  0x24, 0xf1, 0xc2, 0x14, 0x9d, 0x18, 0x21, 0x73,
+  0x74, 0x31, 0xe7, 0xe1, 0xb8, 0x19, 0xd6, 0x3a,
+  0x7b, 0x8e, 0x11, 0x71, 0xd3, 0xff, 0xe4, 0xaa,
+  0x29, 0x93, 0x58, 0x2d, 0xfe, 0xc6, 0x8b, 0xe2,
+  0x7f, 0x07, 0xf5, 0x44, 0xc7, 0x8e, 0x9f, 0xff,
+  0xb3, 0x5c, 0xdc, 0x8b, 0xb7, 0xd0, 0x0e, 0xd1,
+  0x58, 0x54, 0xda, 0xc3, 0xa7, 0xc3, 0xb7, 0xbd,
+  0x46, 0x98, 0x4e, 0x7b, 0x57, 0x27, 0x9a, 0x61,
+  0x39, 0x80, 0x86, 0xa0, 0x4e, 0x7f, 0x77, 0xef,
+  0xe9, 0x04, 0x06, 0xa0, 0x4e, 0x7f, 0x53, 0x2b,
+  0xba, 0x5c, 0xf1, 0xa6, 0x13, 0x9b, 0x38, 0x34,
+  0xc2, 0x73, 0x04, 0x27, 0x98, 0x4e, 0x31, 0x34,
+  0xc7, 0xcd, 0x36, 0x5c, 0xa2, 0x2a, 0x20, 0x2e,
+  0x42, 0x09, 0x1c, 0xb4, 0x59, 0x84, 0xec, 0x7c,
+  0xf2, 0xdb, 0xe9, 0xfb, 0x06, 0x3c, 0x88, 0xa2,
+  0xa8, 0x4d, 0x4a, 0x53, 0x8e, 0x15, 0xb1, 0x31,
+  0x2d, 0x56, 0xf5, 0x2a, 0xda, 0x7d, 0xc6, 0x0e,
+  0xef, 0x9d, 0x3e, 0xee, 0x73, 0xc5, 0x8e, 0x9f,
+  0xc0, 0xe7, 0xd7, 0x2f, 0xfb, 0xc7, 0x47, 0x4f,
+  0x8b, 0x45, 0x30, 0x8b, 0x90, 0x39, 0x2e, 0x3b,
+  0x68, 0xdf, 0x08, 0xb9, 0xff, 0xca, 0xd5, 0x37,
+  0xd7, 0xdd, 0xad, 0xd3, 0x67, 0x4f, 0xff, 0xee,
+  0xe3, 0xf9, 0x4f, 0xed, 0x76, 0x9a, 0xad, 0xde,
+  0xa3, 0xa7, 0x0d, 0x28, 0x78, 0x80, 0xe7, 0xff,
+  0xed, 0xeb, 0x98, 0xa5, 0x53, 0x96, 0x0b, 0x7f,
+  0xb1, 0xa2, 0x03, 0xb1, 0xa8, 0x9f, 0xff, 0xf7,
+  0x7d, 0xd9, 0xd5, 0x9d, 0x8f, 0xbb, 0x9a, 0x02,
+  0xc1, 0x08, 0x4a, 0x9f, 0xc9, 0x82, 0xdf, 0xec,
+  0x68, 0x82, 0x67, 0xf9, 0x35, 0x82, 0xdf, 0xec,
+  0x68, 0xbe, 0x67, 0xdb, 0x5d, 0xdc, 0xa7, 0x07,
+  0xf4, 0xc7, 0x53, 0xfe, 0x7b, 0xdf, 0x5f, 0xcd,
+  0x77, 0xd7, 0x1d, 0x38, 0x21, 0x09, 0x53, 0xf6,
+  0xab, 0x8d, 0xe2, 0x55, 0x8b, 0xc8, 0x79, 0x13,
+  0x3d, 0x60, 0x9f, 0xf9, 0xe5, 0x23, 0xf4, 0xee,
+  0x3d, 0xcd, 0xc7, 0x4f, 0xff, 0x73, 0x7f, 0xbc,
+  0x9a, 0xbb, 0x00, 0x10, 0x5c, 0x74, 0xe0, 0x84,
+  0x25, 0x4f, 0xee, 0x60, 0x4e, 0xe3, 0xfa, 0x2a,
+  0xc5, 0xe4, 0xff, 0xfc, 0xbd, 0xf2, 0x6a, 0xef,
+  0x8e, 0x30, 0x3c, 0xb5, 0x4c, 0x78, 0xe9, 0x7d,
+  0x51, 0x57, 0x72, 0x24, 0x39, 0x54, 0x5e, 0xe1,
+  0xb4, 0x24, 0x8a, 0x49, 0xd4, 0x63, 0x73, 0xfe,
+  0xcd, 0x20, 0xd2, 0xa9, 0xdd, 0x1e, 0x20, 0x89,
+  0xfc, 0x98, 0x2d, 0xfe, 0xc6, 0x88, 0x22, 0xc7,
+  0x93, 0x3f, 0xbb, 0xf5, 0x11, 0xd8, 0x4e, 0x80,
+  0x1f, 0xe7, 0x52, 0xe7, 0xf9, 0x3b, 0xae, 0x79,
+  0x5f, 0x7c, 0xe9, 0xff, 0xef, 0x0e, 0xb2, 0xa9,
+  0xbd, 0x77, 0x2b, 0xb3, 0xa1, 0xc8, 0x88, 0xe9,
+  0xd4, 0xfe, 0xd7, 0x35, 0x50, 0x3e, 0xf9, 0xd3,
+  0xdb, 0x5b, 0x61, 0x3a, 0x7f, 0xfd, 0x73, 0xdd,
+  0x4c, 0xad, 0x93, 0x59, 0x5b, 0x84, 0xe9, 0xf6,
+  0x6a, 0x9c, 0xe9, 0xc1, 0xfc, 0xf3, 0x23, 0x9f,
+  0x9a, 0xbb, 0x5f, 0xdd, 0xf3, 0xa7, 0xe5, 0x25,
+  0xee, 0xb8, 0xf1, 0xd1, 0xc1, 0xf1, 0xec, 0xca,
+  0x70, 0xf3, 0xa1, 0xd3, 0xfe, 0xfe, 0xb6, 0x0b,
+  0x7f, 0xb1, 0xa2, 0x11, 0x84, 0x3e, 0x2b, 0x87,
+  0x67, 0xff, 0x26, 0x3f, 0xcf, 0x5b, 0xed, 0xce,
+  0xca, 0x1d, 0x3f, 0xfd, 0xfe, 0xf7, 0x3c, 0xaf,
+  0xaa, 0xc1, 0x08, 0x4e, 0x96, 0x70, 0x89, 0xe5,
+  0x93, 0x67, 0x04, 0x21, 0x2a, 0x7f, 0xb0, 0x1e,
+  0x38, 0xbb, 0x38, 0x2a, 0xc5, 0xe4, 0xc1, 0x09,
+  0x53, 0x82, 0x10, 0x95, 0x3f, 0x7b, 0xdc, 0x55,
+  0x28, 0x55, 0x8b, 0xc8, 0xea, 0x2d, 0x82, 0x8e,
+  0xbe, 0x65, 0x3e, 0x6d, 0xf1, 0xcd, 0x45, 0x58,
+  0xd9, 0xce, 0x08, 0x42, 0x54, 0xea, 0x20, 0x95,
+  0x62, 0xf2, 0x40, 0xd9, 0xff, 0xe9, 0x5a, 0x7e,
+  0xe3, 0xa8, 0xef, 0x63, 0xa7, 0xf7, 0x31, 0xe3,
+  0x6b, 0x93, 0x83, 0xa7, 0xf6, 0xab, 0x8b, 0xb3,
+  0x54, 0x3a, 0x05, 0x13, 0x15, 0x2c, 0xe9, 0xc4,
+  0x22, 0x3b, 0xf2, 0x18, 0x13, 0x9f, 0xbd, 0x3d,
+  0xe8, 0x3a, 0x7f, 0xf6, 0x5e, 0xff, 0xa0, 0xc6,
+  0x4a, 0xa2, 0x8e, 0x9f, 0x9b, 0x74, 0xae, 0xd6,
+  0x2a, 0x7f, 0xb9, 0x77, 0x1f, 0x75, 0x37, 0x7c,
+  0xe9, 0xe4, 0xf5, 0x2e, 0x2a, 0x70, 0x42, 0x12,
+  0xa7, 0xff, 0xb9, 0xa0, 0x33, 0x3b, 0xaa, 0xed,
+  0x3a, 0xf1, 0x56, 0x2f, 0x25, 0x8c, 0x89, 0xe5,
+  0x1f, 0x42, 0x27, 0x4c, 0xe2, 0xb7, 0xd2, 0xb6,
+  0x5d, 0x58, 0x6e, 0x4f, 0xff, 0x95, 0x8c, 0x9d,
+  0xfd, 0x53, 0x8b, 0xbc, 0x5c, 0x74, 0xf9, 0x35,
+  0x45, 0xd8, 0x74, 0x21, 0xfe, 0x69, 0x52, 0x7f,
+  0xfb, 0x6b, 0xb3, 0xbc, 0x77, 0xc3, 0x9d, 0xfb,
+  0xe7, 0x4f, 0xff, 0xf7, 0x15, 0xd8, 0x72, 0xf3,
+  0x6a, 0xfd, 0x52, 0xe7, 0x63, 0xfa, 0x3a, 0x31,
+  0x18, 0x1e, 0xa7, 0x08, 0xcf, 0x7b, 0x79, 0x35,
+  0xd0, 0x89, 0xe1, 0xdb, 0x25, 0xba, 0xee, 0x31,
+  0xb5, 0xa1, 0x54, 0x24, 0x6a, 0x85, 0x7d, 0x61,
+  0x4e, 0x08, 0x42, 0xf6, 0x18, 0x14, 0x95, 0x3b,
+  0xa8, 0xf3, 0x2e, 0x86, 0x60, 0x61, 0xc3, 0x39,
+  0x72, 0x74, 0xe9, 0xff, 0xec, 0xed, 0xb5, 0x7f,
+  0x6f, 0xd2, 0xb8, 0x0f, 0x3a, 0x4f, 0xb8, 0xfb,
+  0xf8, 0x1d, 0x9f, 0xaa, 0xb6, 0xeb, 0xb5, 0x1d,
+  0x3f, 0xee, 0xa6, 0xab, 0xe0, 0xf7, 0xe8, 0x74,
+  0xff, 0xd4, 0xfd, 0x8e, 0x3f, 0x60, 0x84, 0x27,
+  0x4f, 0xff, 0x75, 0x1d, 0xcb, 0x9e, 0xb7, 0xdb,
+  0x9d, 0x94, 0x3a, 0x31, 0x30, 0x66, 0x2f, 0xa9,
+  0xf0, 0x11, 0x27, 0xf2, 0x75, 0xdd, 0xcc, 0x01,
+  0xd3, 0xf9, 0xd8, 0x34, 0xea, 0x3c, 0x74, 0xff,
+  0xf2, 0x2e, 0x41, 0xb7, 0x3d, 0x77, 0x1e, 0xd8,
+  0x9e, 0xef, 0x79, 0xff, 0xec, 0xd2, 0x75, 0xb3,
+  0x55, 0xd8, 0x81, 0x8e, 0x9f, 0x7d, 0x33, 0xba,
+  0x3a, 0x76, 0xbe, 0xf6, 0x74, 0xfe, 0xd5, 0x77,
+  0x60, 0x7e, 0xce, 0x87, 0x93, 0x23, 0xe1, 0x7f,
+  0xa9, 0x9a, 0x26, 0xb8, 0x7e, 0x7f, 0xfe, 0xee,
+  0x52, 0xee, 0x59, 0x5f, 0xee, 0x2c, 0xe4, 0x7c,
+  0xe9, 0xff, 0x65, 0x2e, 0xc1, 0x6f, 0xf6, 0x34,
+  0x40, 0xd3, 0xec, 0xd5, 0x7d, 0xdc, 0x91, 0x4b,
+  0xd5, 0xe9, 0xff, 0xff, 0xfb, 0x35, 0x5f, 0xed,
+  0xfe, 0x54, 0x1f, 0xfd, 0x2e, 0xce, 0x39, 0x62,
+  0xbf, 0xaf, 0xb8, 0xf1, 0x05, 0xcf, 0xfb, 0xfe,
+  0xfb, 0x7f, 0x1c, 0xaf, 0x84, 0xf1, 0x05, 0xcf,
+  0xfd, 0x5d, 0xd7, 0x69, 0xdd, 0x72, 0xbe, 0x13,
+  0xc4, 0x17, 0x3f, 0x93, 0x7d, 0xd7, 0x2b, 0xe1,
+  0x3c, 0x41, 0x73, 0xf2, 0xb3, 0x8e, 0x57, 0xc2,
+  0x78, 0x82, 0xe7, 0xff, 0xfb, 0xfb, 0xdd, 0xab,
+  0x95, 0x1a, 0xbb, 0x1d, 0xdf, 0x7b, 0x02, 0x78,
+  0x82, 0xe6, 0x7f, 0x97, 0x09, 0xd0, 0xb2, 0x80,
+  0xab, 0x7a, 0x27, 0x4f, 0xe2, 0xaa, 0xa5, 0xbb,
+  0x28, 0xfa, 0x7b, 0xc4, 0x1e, 0x74, 0xff, 0xd5,
+  0xdd, 0x76, 0x9d, 0xd7, 0x2b, 0xe1, 0x3c, 0x41,
+  0x73, 0xfc, 0xb5, 0x1b, 0x6f, 0x72, 0xbe, 0x13,
+  0xc4, 0x17, 0x3e, 0xd5, 0x11, 0x5c, 0x99, 0x14,
+  0x5c, 0xd5, 0xa7, 0xff, 0x72, 0x6a, 0xed, 0x93,
+  0x54, 0xe5, 0x7c, 0x27, 0x88, 0x2e, 0x7f, 0xff,
+  0xee, 0xf7, 0x6a, 0xe5, 0x76, 0x72, 0xa3, 0x57,
+  0x63, 0xbb, 0xef, 0x60, 0x4f, 0x10, 0x5c, 0x62,
+  0x64, 0xcf, 0xa1, 0xfa, 0xe4, 0xff, 0x57, 0x63,
+  0xbb, 0xef, 0x60, 0x4f, 0x10, 0x5c, 0xff, 0xf7,
+  0xfb, 0xee, 0xa5, 0x77, 0xc7, 0x08, 0x28, 0x54,
+  0xff, 0xb1, 0xce, 0xba, 0x83, 0xd7, 0x97, 0xcf,
+  0x10, 0x5c, 0x32, 0x3a, 0x05, 0x22, 0x8a, 0x13,
+  0xfe, 0x6d, 0x8e, 0xbc, 0x14, 0xe4, 0x13, 0xc4,
+  0x17, 0x3f, 0x57, 0x75, 0xae, 0xc0, 0x68, 0x02,
+  0xe7, 0xd8, 0x0e, 0x57, 0xc2, 0x78, 0x82, 0xe6,
+  0xcd, 0x31, 0xf9, 0xd4, 0xee, 0x1f, 0x47, 0x5d,
+  0x21, 0x7f, 0x3f, 0x2b, 0x38, 0xe5, 0x7c, 0x27,
+  0x88, 0x2e, 0x7f, 0xcd, 0x5d, 0x8e, 0xef, 0xbd,
+  0x81, 0x3c, 0x41, 0x73, 0x67, 0x2f, 0x44, 0x65,
+  0x0f, 0xe7, 0xf5, 0xdb, 0x57, 0xf5, 0xf7, 0x1e,
+  0x20, 0xb9, 0xff, 0x66, 0xd7, 0x67, 0x73, 0x8f,
+  0x71, 0xe2, 0x0b, 0x51, 0xe1, 0x47, 0x0b, 0xb8,
+  0xe0, 0x2c, 0xec, 0x7c, 0xf4, 0x8c, 0x63, 0x51,
+  0x8c, 0xdd, 0x0b, 0x50, 0xb8, 0xcf, 0x81, 0x40,
+  0x01, 0x0d, 0x10, 0x5d, 0x91, 0x01, 0x3f, 0xec,
+  0x75, 0x7d, 0xd7, 0x97, 0x97, 0x3c, 0x74, 0xfe,
+  0x1e, 0xe7, 0x15, 0xb8, 0x27, 0x4f, 0x9f, 0xd7,
+  0x88, 0x0e, 0x9f, 0xb1, 0xef, 0xaa, 0x5e, 0xce,
+  0x8d, 0xa2, 0x2f, 0xcd, 0x3a, 0x4f, 0x3b, 0xc5,
+  0xe3, 0xa6, 0x02, 0x1d, 0x3d, 0xb4, 0x56, 0x1d,
+  0x07, 0x4f, 0xdf, 0x7f, 0x48, 0x20, 0x3a, 0x38,
+  0x36, 0xfd, 0x0a, 0x9f, 0xff, 0xc9, 0xbe, 0x3a,
+  0x97, 0x36, 0xb1, 0xb8, 0x46, 0xe6, 0xa3, 0xa6,
+  0x02, 0x1d, 0x32, 0x5f, 0x3a, 0x7f, 0xb3, 0x54,
+  0x45, 0x73, 0xc5, 0x8e, 0x9f, 0xd4, 0xca, 0xee,
+  0x97, 0x3c, 0x74, 0xc1, 0x09, 0x53, 0xfd, 0xdc,
+  0x5d, 0xee, 0xa6, 0xf8, 0x3a, 0x19, 0x3f, 0x7d,
+  0x8d, 0x88, 0xaa, 0x95, 0xea, 0x44, 0x06, 0x25,
+  0xec, 0x57, 0xa2, 0xf4, 0x3a, 0x09, 0xaf, 0x31,
+  0x69, 0xc1, 0x08, 0x4a, 0x92, 0x8a, 0xb1, 0x79,
+  0x3e, 0xf5, 0xbf, 0xc4, 0xab, 0x23, 0x67, 0x9c,
+  0x2e, 0xa7, 0xf3, 0xfa, 0x4c, 0xae, 0x3c, 0x74,
+  0x23, 0x63, 0x2f, 0x91, 0x98, 0x5f, 0x3c, 0x7c,
+  0xc7, 0x71, 0xaa, 0xd6, 0x1e, 0x7f, 0x49, 0x1e,
+  0xea, 0x35, 0x21, 0xa3, 0x74, 0xaf, 0xf5, 0xc9,
+  0x73, 0xd8, 0xc9, 0xa3, 0xa7, 0xb1, 0x59, 0xa3,
+  0xa7, 0xbd, 0xee, 0x6e, 0x3a, 0x10, 0xf8, 0xdf,
+  0x1f, 0xbc, 0x20, 0x9f, 0xbb, 0x77, 0x0a, 0xf7,
+  0x1d, 0x3f, 0xfc, 0xfb, 0xba, 0x9c, 0x95, 0xd4,
+  0xbf, 0xad, 0xbc, 0x74, 0x22, 0x21, 0x76, 0x5f,
+  0x3d, 0xcb, 0xf9, 0x73, 0x3a, 0x7e, 0x79, 0x67,
+  0x2f, 0x05, 0xe3, 0xa6, 0x73, 0xc7, 0x4f, 0xab,
+  0x9b, 0x75, 0x0e, 0x9f, 0xfe, 0xaa, 0x73, 0xb6,
+  0xbb, 0xe0, 0xa5, 0x10, 0x05, 0x4f, 0xe0, 0x60,
+  0xb7, 0xfb, 0x1e, 0x20, 0x48, 0x72, 0x2c, 0xf8,
+  0x27, 0x15, 0x19, 0xed, 0x3d, 0xfd, 0x3a, 0x79,
+  0xfa, 0x7e, 0x8e, 0x8c, 0x3c, 0x4a, 0x91, 0x4f,
+  0xee, 0xf8, 0x69, 0x44, 0x01, 0xd3, 0x82, 0x10,
+  0x9f, 0x0f, 0xa9, 0xdf, 0xde, 0x0b, 0x87, 0xd5,
+  0x8d, 0x4c, 0x70, 0x89, 0x40, 0x2d, 0xcf, 0xff,
+  0xb3, 0xbb, 0xbf, 0x6a, 0x6a, 0xb7, 0x7b, 0x9c,
+  0x87, 0x43, 0xc7, 0xf9, 0x7c, 0x92, 0x17, 0xaa,
+  0xac, 0x87, 0x1a, 0x64, 0x32, 0xb6, 0xe9, 0xf1,
+  0x98, 0xcf, 0xb7, 0xa4, 0xd5, 0x0a, 0x9e, 0x64,
+  0xd5, 0x0a, 0x98, 0x21, 0x2a, 0x1c, 0x7b, 0xb8,
+  0x4e, 0x12, 0x09, 0xb0, 0x25, 0x58, 0xd7, 0x4f,
+  0xff, 0xb3, 0x48, 0xd9, 0x9d, 0xd5, 0x76, 0x9d,
+  0x78, 0xe8, 0x01, 0xfc, 0x04, 0x96, 0x7f, 0xff,
+  0x22, 0xed, 0xf4, 0x1c, 0xb5, 0x4c, 0x6a, 0xff,
+  0x75, 0x43, 0xa7, 0xf2, 0xcf, 0xba, 0xb7, 0x20,
+  0x9d, 0x39, 0xde, 0x27, 0x4f, 0x9d, 0x9a, 0xce,
+  0x0a, 0x96, 0xd6, 0x3c, 0x1d, 0x0d, 0x4c, 0x04,
+  0x3a, 0x60, 0x21, 0xd3, 0xf7, 0x6e, 0x76, 0x76,
+  0xdb, 0x35, 0x40, 0x15, 0x9f, 0xfb, 0x55, 0xc5,
+  0x73, 0x40, 0x63, 0xfa, 0x3a, 0x7f, 0x3e, 0xdb,
+  0x1e, 0x69, 0xc1, 0xd3, 0xc0, 0x57, 0xba, 0x87,
+  0xf7, 0xa4, 0x69, 0xcb, 0xf8, 0xf9, 0xd0, 0x87,
+  0xb1, 0xe7, 0x33, 0x82, 0x10, 0x95, 0x3f, 0x26,
+  0x5f, 0xed, 0xd4, 0x2a, 0xc5, 0xe4, 0xf0, 0x7f,
+  0xae, 0x3a, 0x66, 0xa9, 0xd3, 0x82, 0x10, 0x95,
+  0x3f, 0x6f, 0xef, 0xd7, 0x7a, 0x2a, 0xc5, 0xe4,
+  0xfb, 0x01, 0x98, 0xb1, 0xd2, 0xa7, 0x24, 0x4a,
+  0x89, 0x8f, 0x4f, 0xa7, 0xb7, 0xdb, 0x9d, 0xc2,
+  0x3b, 0x72, 0x16, 0xd0, 0x8b, 0x81, 0xee, 0x22,
+  0xc6, 0x4b, 0xee, 0xc2, 0xa7, 0x58, 0xc6, 0x28,
+  0x79, 0xa8, 0xca, 0xe7, 0xe4, 0x50, 0x8f, 0xe8,
+  0xe9, 0xff, 0xed, 0xa9, 0xf7, 0x53, 0x96, 0x77,
+  0xb9, 0xb0, 0x1d, 0x15, 0x3f, 0xdd, 0x15, 0x4a,
+  0xcb, 0xd1, 0xfc, 0x8a, 0x12, 0x50, 0x9b, 0xd1,
+  0x88, 0xba, 0x50, 0x67, 0x12, 0x96, 0x32, 0xb4,
+  0xf4, 0xbf, 0x19, 0xab, 0x47, 0x4a, 0xfc, 0xa2,
+  0x3d, 0xc2, 0x71, 0x68, 0xf3, 0x86, 0x71, 0xf1,
+  0x51, 0xb9, 0x56, 0x74, 0x5b, 0xe9, 0xbf, 0x40,
+  0x94, 0x49, 0xd9, 0xcb, 0xda, 0x53, 0xf1, 0x35,
+  0x59, 0x93, 0x5d, 0x19, 0x4a, 0xe8, 0x5b, 0x84,
+  0x89, 0x7e, 0x57, 0x7f, 0x39, 0xd6, 0xdb, 0xc8,
+  0x7e, 0x45, 0x9f, 0xd2, 0x11, 0xd7, 0xe4, 0xe9,
+  0x3f, 0xad, 0x82, 0xdf, 0xec, 0x68, 0xb8, 0xe7,
+  0xf5, 0xb0, 0x5b, 0xfd, 0x8d, 0x17, 0x5c, 0xff,
+  0xd6, 0xf7, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x28,
+  0xc2, 0x3f, 0xbe, 0xbb, 0x8a, 0x38, 0x3b, 0xbe,
+  0x76, 0xc7, 0x7b, 0x87, 0x85, 0xed, 0x03, 0xef,
+  0xd3, 0x5a, 0x86, 0xda, 0x3b, 0xbc, 0x3b, 0x9f,
+  0xfd, 0x65, 0x7b, 0xad, 0x82, 0xdf, 0xec, 0x68,
+  0x96, 0xa7, 0xc2, 0xdf, 0xec, 0x68, 0x8d, 0xe7,
+  0xfd, 0xee, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x5f,
+  0x95, 0xb0, 0xfd, 0x94, 0x61, 0x3f, 0xad, 0x82,
+  0xdf, 0xec, 0x68, 0xaa, 0xe7, 0xfa, 0xfe, 0x77,
+  0x1f, 0xd7, 0xa8, 0xe9, 0xb8, 0xd9, 0xd3, 0xf6,
+  0x0b, 0x7f, 0xb1, 0xa2, 0x40, 0x8e, 0x47, 0x99,
+  0x61, 0x79, 0xf5, 0x3f, 0xbe, 0xf9, 0xd0, 0xe3,
+  0xcb, 0x7c, 0x92, 0x2f, 0xa3, 0xd3, 0xe1, 0xa3,
+  0x3f, 0xf7, 0x71, 0xeb, 0x2f, 0xa7, 0x7b, 0x9a,
+  0x3a, 0x2c, 0x7e, 0x02, 0x53, 0x3f, 0xad, 0x82,
+  0xdf, 0xec, 0x68, 0xb2, 0x27, 0xf5, 0xb0, 0x5b,
+  0xfd, 0x8d, 0x16, 0xbc, 0xfe, 0xb6, 0x0b, 0x7f,
+  0xb1, 0xa2, 0xe4, 0x9f, 0x0b, 0x7f, 0xb1, 0xa2,
+  0xec, 0x9f, 0xf7, 0xba, 0xd8, 0x2d, 0xfe, 0xc6,
+  0x8a, 0x3a, 0x56, 0xc3, 0xf6, 0x51, 0x84, 0xf8,
+  0x5b, 0xfd, 0x8d, 0x14, 0xac, 0xff, 0xff, 0xf5,
+  0x51, 0xe4, 0xae, 0xd7, 0x7f, 0x15, 0xdd, 0x9a,
+  0xbb, 0x5a, 0xa8, 0xf6, 0x1d, 0x3e, 0xb2, 0xbd,
+  0xd6, 0xc4, 0x59, 0x2c, 0x61, 0x0f, 0x2e, 0x77,
+  0xba, 0x19, 0x0f, 0x93, 0xee, 0x39, 0xf5, 0x10,
+  0x80, 0xee, 0x87, 0x7a, 0x85, 0x8a, 0xe8, 0x6c,
+  0xcf, 0xf3, 0xad, 0x82, 0xdf, 0xec, 0x68, 0x8e,
+  0x27, 0xfb, 0x76, 0xc1, 0x6f, 0xf6, 0x34, 0x56,
+  0xb2, 0xb7, 0xa2, 0x0b, 0x48, 0x33, 0xff, 0xac,
+  0xaf, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x12, 0xdc,
+  0xd8, 0xf9, 0xd3, 0xfb, 0x8c, 0x52, 0x93, 0x74,
+  0x3a, 0x1f, 0x3c, 0x9d, 0x8b, 0x4e, 0xaf, 0x0e,
+  0x3a, 0x73, 0x94, 0xc7, 0x41, 0xa2, 0x1b, 0x9f,
+  0xf7, 0xba, 0xd8, 0x2d, 0xfe, 0xc6, 0x89, 0x82,
+  0x70, 0xdc, 0x02, 0xa5, 0x64, 0x46, 0xa3, 0xc4,
+  0x7c, 0x0e, 0xb0, 0xda, 0x85, 0xf4, 0x8d, 0x39,
+  0x57, 0x09, 0x53, 0xfe, 0xf7, 0x5b, 0x05, 0xbf,
+  0xd8, 0xd1, 0x31, 0xca, 0xdb, 0x3e, 0x25, 0x0e,
+  0x4f, 0xc9, 0x4e, 0x5a, 0xca, 0x9d, 0x3f, 0xff,
+  0xfc, 0xea, 0x57, 0x2e, 0x0d, 0x2b, 0x8d, 0x94,
+  0xe5, 0x8f, 0xba, 0x9b, 0xee, 0xce, 0x9e, 0x6f,
+  0xf6, 0x34, 0x56, 0x33, 0xfe, 0x5f, 0xcd, 0x77,
+  0x2e, 0x4e, 0xe8, 0xe8, 0xbe, 0x98, 0xdb, 0xe5,
+  0xc3, 0x08, 0x1d, 0x15, 0xcf, 0xfe, 0x4e, 0xea,
+  0xfd, 0xc9, 0xdc, 0x64, 0x13, 0xa7, 0xfd, 0x9c,
+  0x57, 0x28, 0xfb, 0x92, 0xa7, 0x4f, 0xff, 0xfd,
+  0xdb, 0x9e, 0xc6, 0xe5, 0xdb, 0xaf, 0x39, 0x63,
+  0xee, 0xcb, 0xba, 0x0a, 0x1d, 0x3f, 0x97, 0xab,
+  0xcb, 0x39, 0x78, 0x2f, 0x1d, 0x3a, 0xbb, 0xb6,
+  0x27, 0x16, 0xc8, 0xb5, 0x49, 0xd1, 0xfa, 0xfb,
+  0xf4, 0xd7, 0x2c, 0x74, 0xfb, 0xfa, 0xf5, 0xd4,
+  0x3a, 0x3a, 0x78, 0x34, 0x18, 0x9f, 0x06, 0x94,
+  0x40, 0x1d, 0x3e, 0x47, 0x02, 0xe7, 0x1d, 0x39,
+  0x3a, 0xe3, 0xa1, 0x63, 0xc3, 0xd1, 0x44, 0xfc,
+  0x8a, 0xce, 0xee, 0xf9, 0xd2, 0xa1, 0xd1, 0xb3,
+  0x7d, 0xe5, 0xd3, 0x01, 0x0a, 0x98, 0x21, 0x2a,
+  0x36, 0x6a, 0xc2, 0x2b, 0x3f, 0xbd, 0xdd, 0xcd,
+  0x57, 0x65, 0x58, 0xd0, 0xcf, 0x71, 0xef, 0xd0,
+  0xe9, 0xc9, 0xd5, 0x8e, 0x9b, 0xa8, 0x74, 0x2c,
+  0x6c, 0x44, 0x72, 0x78, 0x41, 0x97, 0x87, 0x4e,
+  0xe6, 0x37, 0xce, 0x84, 0x45, 0xbe, 0x2a, 0x6c,
+  0x86, 0xa4, 0x73, 0x57, 0x47, 0x4e, 0x08, 0x42,
+  0x54, 0xff, 0xd8, 0xdc, 0x23, 0xdc, 0xf2, 0xbe,
+  0xf9, 0x56, 0x2f, 0x27, 0xeb, 0x95, 0xbd, 0x03,
+  0xce, 0x9f, 0xcd, 0xba, 0x77, 0x17, 0x79, 0xd3,
+  0x66, 0x8e, 0x87, 0xcf, 0x22, 0xa6, 0x73, 0xff,
+  0xda, 0xdd, 0x2b, 0x9c, 0x77, 0x17, 0x77, 0x28,
+  0x74, 0xac, 0x8a, 0xff, 0xf8, 0x22, 0xc6, 0xa1,
+  0x61, 0x53, 0x65, 0x61, 0xf3, 0xe7, 0x7d, 0x32,
+  0xa2, 0xae, 0x9d, 0xb9, 0x91, 0xcf, 0x85, 0xbf,
+  0xd8, 0xd1, 0x5b, 0xcf, 0xfb, 0xdd, 0x6c, 0x16,
+  0xff, 0x63, 0x44, 0xe1, 0x2b, 0x61, 0xfb, 0x28,
+  0xc2, 0x7c, 0x2d, 0xfe, 0xc6, 0x8b, 0x46, 0x7b,
+  0x16, 0xdd, 0xf3, 0xa5, 0x6c, 0x3d, 0x4a, 0x98,
+  0x4f, 0x37, 0xfb, 0x1a, 0x2d, 0xa9, 0xfa, 0xa8,
+  0xa4, 0xdf, 0x07, 0x4d, 0x6c, 0x13, 0xd8, 0xd1,
+  0x5c, 0xfe, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0xe5,
+  0x9f, 0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x5d, 0xb0,
+  0x8c, 0xc7, 0x87, 0x8a, 0x1d, 0x1b, 0x7f, 0x10,
+  0xbf, 0xbf, 0x2b, 0x3b, 0x73, 0x93, 0xd7, 0xb8,
+  0xc6, 0xaa, 0xf7, 0xd7, 0xfa, 0x16, 0x68, 0xee,
+  0x7f, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x53, 0xcf,
+  0x37, 0xfb, 0x1a, 0x2b, 0x99, 0xfd, 0x6c, 0x16,
+  0xff, 0x63, 0x45, 0x9d, 0x02, 0x7c, 0xd5, 0x2b,
+  0x9f, 0xe7, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x21,
+  0x4f, 0x2f, 0x4a, 0xa2, 0x8e, 0x9f, 0xd9, 0x5a,
+  0x53, 0x05, 0xe3, 0xa5, 0x6c, 0x45, 0xdf, 0x90,
+  0xd1, 0x07, 0x44, 0xf3, 0xff, 0xac, 0xaf, 0x75,
+  0xb0, 0x5b, 0xfd, 0x8d, 0x13, 0xe4, 0x32, 0x7d,
+  0xf7, 0xb8, 0xd7, 0x2a, 0x83, 0x3e, 0x16, 0xff,
+  0x63, 0x45, 0x65, 0x3f, 0xef, 0x75, 0xb0, 0x5b,
+  0xfd, 0x8d, 0x13, 0x74, 0xdb, 0xb6, 0x1f, 0xb2,
+  0x8c, 0x27, 0xff, 0x59, 0x5e, 0xeb, 0x60, 0xb7,
+  0xfb, 0x1a, 0x25, 0x69, 0xf0, 0xb7, 0xfb, 0x1a,
+  0x25, 0xc9, 0xe5, 0xdb, 0xea, 0x1d, 0x3e, 0xb2,
+  0xbd, 0xd6, 0xc3, 0xd3, 0xf3, 0x09, 0xff, 0xad,
+  0xee, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x3b, 0x9f,
+  0xed, 0x57, 0x1d, 0x6f, 0xed, 0x0e, 0x9f, 0x97,
+  0x9d, 0x46, 0xce, 0x9d, 0x3f, 0x5e, 0xbd, 0xca,
+  0xfe, 0x8e, 0x9f, 0x0b, 0x7f, 0xb1, 0xa2, 0xa1,
+  0x9f, 0x65, 0x75, 0x8f, 0x1d, 0x2b, 0x5e, 0xa8,
+  0xb7, 0x5e, 0x17, 0xe1, 0x8e, 0x8c, 0x27, 0xc2,
+  0xdf, 0xec, 0x68, 0xaa, 0x27, 0xfd, 0xee, 0xb6,
+  0x0b, 0x7f, 0xb1, 0xa2, 0x6b, 0x95, 0xb0, 0xfd,
+  0x94, 0x61, 0x3f, 0xad, 0x82, 0xdf, 0xec, 0x68,
+  0xab, 0x27, 0xfe, 0xb7, 0xba, 0xd8, 0x2d, 0xfe,
+  0xc6, 0x89, 0x12, 0x7c, 0x2d, 0xfe, 0xc6, 0x8b,
+  0x4a, 0x7f, 0xde, 0xeb, 0x60, 0xb7, 0xfb, 0x1a,
+  0x27, 0xd9, 0x5b, 0x0f, 0xd9, 0x46, 0x13, 0xff,
+  0xac, 0xaf, 0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x14,
+  0x24, 0xfa, 0xbb, 0x79, 0x04, 0xe9, 0xf0, 0xb7,
+  0xfb, 0x1a, 0x28, 0xf9, 0xff, 0xfb, 0x38, 0xaa,
+  0x73, 0xb6, 0xbb, 0xe0, 0xa5, 0x10, 0x05, 0x4f,
+  0xac, 0xaf, 0x75, 0x91, 0x16, 0x98, 0x4e, 0xbe,
+  0x61, 0x08, 0xba, 0xfa, 0xf4, 0x29, 0x5c, 0x7b,
+  0x89, 0x97, 0xe1, 0xde, 0xd0, 0xc1, 0x7c, 0x9d,
+  0x63, 0xba, 0xc3, 0x08, 0x04, 0xfa, 0x8c, 0x1a,
+  0x7f, 0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x11, 0x4f,
+  0xd8, 0x2d, 0xfe, 0xc6, 0x88, 0xae, 0x7f, 0xaf,
+  0x76, 0xc1, 0x6f, 0xf6, 0x34, 0x57, 0x11, 0x63,
+  0xfa, 0xf3, 0x59, 0xec, 0xaf, 0xe8, 0xe9, 0xfd,
+  0x9b, 0x10, 0x02, 0xea, 0x1d, 0x2b, 0xd7, 0xa7,
+  0xa7, 0x42, 0x09, 0xff, 0xbf, 0x6e, 0xdf, 0x75,
+  0x75, 0x47, 0x0e, 0x9f, 0x66, 0xf8, 0x1c, 0x3a,
+  0x76, 0xa9, 0xba, 0x9f, 0x56, 0x91, 0x27, 0xc2,
+  0xdf, 0xec, 0x68, 0xa7, 0xa1, 0x78, 0x8f, 0xb4,
+  0x84, 0xbe, 0x1a, 0x4f, 0xfe, 0xf7, 0x5b, 0x8e,
+  0xf8, 0x69, 0x44, 0x01, 0xd1, 0x64, 0x40, 0xf0,
+  0x6f, 0x3a, 0xdc, 0x61, 0xd3, 0xe4, 0x70, 0x2e,
+  0x71, 0xd3, 0xcd, 0xfe, 0xc6, 0x8a, 0xce, 0x16,
+  0x3d, 0x31, 0x28, 0x9f, 0x9e, 0x52, 0x75, 0xd4,
+  0x3a, 0x72, 0x3d, 0xb3, 0xa7, 0xda, 0x07, 0x3e,
+  0xb8, 0xe9, 0xf6, 0x2c, 0xf5, 0xc0, 0x3a, 0x56,
+  0xc4, 0x60, 0x09, 0x15, 0x4b, 0xbc, 0x73, 0x99,
+  0x54, 0xff, 0xd6, 0xf7, 0x5b, 0x05, 0xbf, 0xd8,
+  0xd1, 0x22, 0xcf, 0xeb, 0x60, 0xb7, 0xfb, 0x1a,
+  0x2c, 0x99, 0xfd, 0x6c, 0x16, 0xff, 0x63, 0x45,
+  0xb1, 0x3f, 0xad, 0x82, 0xdf, 0xec, 0x68, 0xb6,
+  0xe7, 0xfc, 0xbc, 0x5e, 0x5e, 0x96, 0xab, 0x9d,
+  0x40, 0x1d, 0x3f, 0x27, 0x5d, 0xc5, 0xca, 0x3a,
+  0x7c, 0x2d, 0xfe, 0xc6, 0x8b, 0xc2, 0x7b, 0x4b,
+  0xf9, 0x53, 0xa7, 0xd9, 0xd0, 0x5e, 0x21, 0xd3,
+  0xe4, 0xe7, 0x77, 0xd0, 0xe9, 0xda, 0x40, 0x1d,
+  0x2b, 0x5e, 0x9a, 0x99, 0xeb, 0xc9, 0xb8, 0x5e,
+  0xf9, 0x80, 0x09, 0x3a, 0x53, 0xa2, 0x99, 0xf0,
+  0xb7, 0xfb, 0x1a, 0x2f, 0x49, 0xff, 0x77, 0xf4,
+  0xe4, 0xbf, 0xad, 0xbc, 0x74, 0xfb, 0x15, 0x5f,
+  0xe0, 0xe9, 0x5b, 0x11, 0x31, 0xcc, 0xc2, 0xf1,
+  0x06, 0x11, 0x7f, 0x21, 0xe8, 0x5a, 0xe4, 0x7e,
+  0x0c, 0x49, 0xb8, 0xcb, 0xc5, 0x3d, 0x49, 0x80,
+  0x3b, 0xe9, 0xdd, 0xd1, 0xbc, 0x06, 0x30, 0xd9,
+  0xec, 0xaf, 0xe8, 0xe9, 0xfd, 0x9b, 0x10, 0x02,
+  0xea, 0x1d, 0x2b, 0xd7, 0xa7, 0xa7, 0x42, 0x09,
+  0xf0, 0xb7, 0xfb, 0x1a, 0x22, 0x39, 0xff, 0xea,
+  0xdd, 0x4a, 0x62, 0xbb, 0x8b, 0xb9, 0x25, 0xe8,
+  0x3a, 0x7f, 0xce, 0x47, 0x87, 0x35, 0xad, 0xe8,
+  0xe9, 0x9e, 0x51, 0x53, 0x04, 0x25, 0x4f, 0xfc,
+  0xeb, 0x35, 0x76, 0xb5, 0x51, 0xeb, 0x00, 0xd6,
+  0x84, 0x5e, 0x7f, 0x65, 0xef, 0xb9, 0x5f, 0xd1,
+  0xd3, 0xff, 0xf3, 0x58, 0x7f, 0xbb, 0xd5, 0x85,
+  0x35, 0xdf, 0x01, 0xd0, 0xbc, 0x54, 0x19, 0x85,
+  0xac, 0x60, 0xfa, 0xd7, 0xb5, 0xe9, 0x75, 0x71,
+  0xac, 0xf8, 0x5b, 0xfd, 0x8d, 0x11, 0x74, 0xfb,
+  0x40, 0xe7, 0xd7, 0x16, 0xcf, 0x69, 0x5b, 0x0f,
+  0x9f, 0xcc, 0x22, 0xc8, 0xf7, 0x74, 0x34, 0x67,
+  0xfe, 0x57, 0xba, 0xd8, 0x2d, 0xfe, 0xc6, 0x89,
+  0x9a, 0x73, 0xe9, 0x43, 0xa7, 0x36, 0xd4, 0x74,
+  0xff, 0xec, 0xbc, 0xde, 0xb6, 0xdb, 0xe3, 0x58,
+  0xc7, 0x4f, 0xff, 0xb8, 0xdf, 0x5e, 0xca, 0x6f,
+  0xeb, 0x60, 0x84, 0x25, 0x4f, 0x37, 0xfb, 0x1a,
+  0x2c, 0xf9, 0xff, 0xed, 0x8d, 0x7f, 0x96, 0x2e,
+  0xee, 0x53, 0x3a, 0x74, 0xe0, 0x84, 0x25, 0x4f,
+  0xfb, 0xdd, 0x4e, 0xe3, 0x71, 0x82, 0x55, 0x8b,
+  0xc9, 0xfe, 0x4a, 0xef, 0x8e, 0xff, 0xac, 0x74,
+  0xff, 0x6f, 0xbc, 0x73, 0xe2, 0xed, 0x50, 0xe8,
+  0x64, 0xec, 0xc5, 0x62, 0xa5, 0x60, 0x6d, 0xd2,
+  0x5a, 0xe3, 0x99, 0xff, 0xff, 0xfb, 0x30, 0x14,
+  0xcc, 0xed, 0xfe, 0x63, 0xd4, 0xca, 0xda, 0x9d,
+  0xc7, 0x95, 0x8a, 0x3a, 0x75, 0x11, 0xe3, 0xa7,
+  0x2f, 0xe5, 0x4e, 0x87, 0x23, 0x12, 0x90, 0x8a,
+  0xd0, 0xe4, 0xf3, 0xe0, 0xb9, 0x8e, 0x9f, 0x57,
+  0xa9, 0x82, 0x64, 0xff, 0xb6, 0x2e, 0xc1, 0x7a,
+  0xef, 0xe0, 0xd1, 0x06, 0xd8, 0xd2, 0xcf, 0xbd,
+  0xb6, 0xa4, 0x3a, 0x7e, 0x75, 0x7b, 0xef, 0xe8,
+  0xe9, 0x63, 0x1e, 0x9f, 0x49, 0x67, 0xff, 0xfd,
+  0xe1, 0xd6, 0x57, 0x49, 0x9d, 0x7f, 0x58, 0x3b,
+  0x7b, 0xd4, 0x74, 0x39, 0x34, 0x0c, 0x85, 0x7f,
+  0x49, 0xa7, 0xe1, 0xce, 0x29, 0x54, 0x3a, 0x7f,
+  0xff, 0x5d, 0xdf, 0xbf, 0xcb, 0x9f, 0x7f, 0x54,
+  0xdb, 0xf5, 0xd8, 0x4e, 0x9f, 0xff, 0xea, 0x51,
+  0x07, 0x49, 0x65, 0x66, 0xa9, 0xce, 0x9e, 0xec,
+  0x3a, 0x7a, 0xb9, 0xb5, 0xc7, 0x46, 0xd1, 0x13,
+  0x56, 0x69, 0x95, 0x7a, 0x9a, 0x2f, 0xc9, 0xff,
+  0x9d, 0xab, 0x9c, 0xe5, 0x6b, 0x48, 0xa3, 0xa7,
+  0xfe, 0xde, 0x77, 0x32, 0x9c, 0x9d, 0x45, 0x1d,
+  0x0f, 0xa2, 0x2e, 0x88, 0xd3, 0xdd, 0xea, 0x31,
+  0xd0, 0x89, 0x8d, 0x70, 0x47, 0x90, 0xb3, 0xf2,
+  0x49, 0xff, 0xff, 0xaf, 0x12, 0xbb, 0x55, 0x96,
+  0x77, 0x8f, 0x3a, 0xed, 0xfa, 0x36, 0xde, 0x3a,
+  0x7d, 0x76, 0x53, 0x7d, 0x3a, 0x7c, 0x9c, 0xee,
+  0xfa, 0x1d, 0x32, 0xf6, 0xa3, 0xa7, 0xff, 0xfd,
+  0x5d, 0xbf, 0xac, 0x7f, 0x42, 0x29, 0xa0, 0x73,
+  0xeb, 0xab, 0x87, 0x4e, 0x08, 0x42, 0x54, 0xf7,
+  0x1c, 0x7f, 0x4a, 0xb1, 0x79, 0x08, 0x8d, 0x86,
+  0x1b, 0xdc, 0x22, 0xe7, 0xfe, 0xce, 0xbf, 0xac,
+  0x1d, 0xbd, 0xea, 0x3a, 0x7d, 0x9a, 0x72, 0xaa,
+  0x74, 0x21, 0xf5, 0xd1, 0x12, 0x60, 0x54, 0xe9,
+  0xf9, 0xe5, 0x9c, 0xbc, 0x17, 0x8e, 0x9f, 0xd7,
+  0xeb, 0x9a, 0xae, 0xf4, 0x74, 0xdb, 0x13, 0xa1,
+  0x7a, 0x9f, 0xf6, 0xcd, 0x2a, 0x6b, 0x3f, 0xfb,
+  0x8e, 0x13, 0x81, 0x4d, 0x6d, 0xb7, 0xc1, 0xd2,
+  0xb2, 0xf4, 0x65, 0x9a, 0xde, 0x90, 0xe7, 0x03,
+  0x79, 0x1f, 0xfb, 0xf1, 0x8e, 0x6c, 0xd5, 0x68,
+  0xe2, 0x04, 0xd5, 0x45, 0x95, 0x94, 0x1b, 0xe8,
+  0x20, 0x7a, 0xe9, 0x45, 0x23, 0x01, 0xd4, 0x27,
+  0x82, 0x42, 0xbf, 0x09, 0x4e, 0x66, 0xb1, 0x66,
+  0x65, 0xcd, 0x69, 0x70, 0x33, 0xff, 0xac, 0xaf,
+  0x75, 0xb0, 0x5b, 0xfd, 0x8d, 0x13, 0x64, 0xfe,
+  0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0xad, 0x9f, 0xce,
+  0x75, 0xda, 0xea, 0x38, 0xe9, 0xec, 0xaf, 0xe8,
+  0xe9, 0x5e, 0xb8, 0x7a, 0x9d, 0x34, 0x9f, 0x0b,
+  0x7f, 0xb1, 0xa2, 0xb4, 0x9f, 0xfe, 0x64, 0x1c,
+  0x07, 0xab, 0xdc, 0x9b, 0x63, 0xa7, 0xff, 0x9d,
+  0x4c, 0xea, 0x2b, 0xf3, 0x5a, 0x45, 0x1d, 0x36,
+  0xb4, 0x88, 0x97, 0xf4, 0xa9, 0xfc, 0x8b, 0xb9,
+  0xeb, 0xa8, 0x03, 0xa7, 0xe7, 0xb2, 0xbb, 0xc5,
+  0x1d, 0x3f, 0xd9, 0x79, 0xd4, 0x0b, 0xee, 0xa1,
+  0xd3, 0xf9, 0xd9, 0xaf, 0xe8, 0x2e, 0x3a, 0x56,
+  0x5e, 0x27, 0xe5, 0x85, 0x9b, 0x86, 0x3d, 0x4b,
+  0x7c, 0xdb, 0xa5, 0xba, 0x3c, 0x9f, 0xd6, 0xc1,
+  0x6f, 0xf6, 0x34, 0x58, 0x13, 0xe1, 0x6f, 0xf6,
+  0x34, 0x4e, 0xb3, 0xff, 0xfa, 0xa8, 0xf7, 0x18,
+  0xab, 0x52, 0x99, 0x5d, 0xd2, 0xe7, 0x8e, 0x9f,
+  0x59, 0x5e, 0xeb, 0x62, 0x25, 0x56, 0x30, 0x9f,
+  0x0b, 0x7f, 0xb1, 0xa2, 0xd9, 0x9f, 0xf0, 0x12,
+  0x96, 0xae, 0xdb, 0xc4, 0xe9, 0x5b, 0x0f, 0xb3,
+  0xcc, 0x27, 0x9b, 0xfd, 0x8d, 0x17, 0x34, 0x94,
+  0x74, 0xd6, 0xc1, 0x37, 0x61, 0x2b, 0x9f, 0xd6,
+  0xc1, 0x6f, 0xf6, 0x34, 0x5d, 0xf3, 0xd6, 0xbf,
+  0xc0, 0x0e, 0x84, 0x6c, 0xaf, 0xb2, 0x99, 0xc2,
+  0xc6, 0x0f, 0xa9, 0x6e, 0x54, 0x08, 0xb9, 0x2a,
+  0x1a, 0x00, 0x85, 0x65, 0x18, 0x74, 0x57, 0xcc,
+  0xee, 0x7f, 0x75, 0xec, 0xbc, 0xd2, 0x5f, 0x3a,
+  0x7c, 0x2d, 0xfe, 0xc6, 0x89, 0x5e, 0x7e, 0xaf,
+  0x17, 0x78, 0xb8, 0xe9, 0xde, 0xeb, 0x22, 0x25,
+  0xb0, 0xe2, 0x86, 0x13, 0xb4, 0x9c, 0x15, 0x3f,
+  0xfa, 0xbf, 0xbd, 0x23, 0xb6, 0x2f, 0x5c, 0x02,
+  0xa7, 0xf7, 0xb5, 0xb8, 0x15, 0xee, 0xc8, 0x7c,
+  0xf4, 0x1c, 0x95, 0x94, 0x8f, 0x45, 0xd0, 0xa6,
+  0x9f, 0xfd, 0x65, 0x7b, 0xad, 0x82, 0xdf, 0xec,
+  0x68, 0x98, 0x67, 0xff, 0xec, 0xb7, 0x31, 0xf0,
+  0x5a, 0xfe, 0x9c, 0x14, 0xa3, 0x8e, 0x9f, 0xfa,
+  0xf5, 0xc7, 0xdd, 0x77, 0xeb, 0xa8, 0xe3, 0xa7,
+  0xfb, 0xa9, 0xef, 0x6a, 0xff, 0x89, 0xd3, 0xf2,
+  0x93, 0x3b, 0xa5, 0xf3, 0xa7, 0xc9, 0x9d, 0xd2,
+  0xf9, 0xd3, 0xf5, 0x77, 0xaa, 0x7b, 0xfc, 0x8f,
+  0x61, 0x45, 0xf3, 0xff, 0xfe, 0xee, 0x06, 0xf3,
+  0x59, 0x5e, 0x5d, 0xc7, 0xb7, 0x9d, 0x7d, 0xd4,
+  0x3a, 0x7e, 0x5d, 0xcf, 0x5d, 0x40, 0x1d, 0x3f,
+  0xf9, 0x34, 0x04, 0x76, 0x3f, 0xa7, 0xae, 0x09,
+  0xd0, 0x87, 0xfb, 0xb3, 0x19, 0xfa, 0x9b, 0xbe,
+  0xaf, 0xd1, 0xd3, 0xff, 0xfe, 0x1c, 0x5c, 0x9d,
+  0xd7, 0x2e, 0x7d, 0x4a, 0xfe, 0xf4, 0x9a, 0xa1,
+  0xd2, 0xc7, 0xd1, 0x3e, 0x25, 0xf3, 0xdf, 0xcf,
+  0x8c, 0x3a, 0x56, 0x5e, 0x2b, 0x1e, 0xe1, 0x29,
+  0xa1, 0x22, 0xb2, 0x45, 0x61, 0xe1, 0xd8, 0x60,
+  0x5c, 0x51, 0x3e, 0x16, 0xff, 0x63, 0x45, 0x5d,
+  0x3f, 0xce, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x3c,
+  0x95, 0xb0, 0xfc, 0x7c, 0xc2, 0x7f, 0x5b, 0x05,
+  0xbf, 0xd8, 0xd1, 0x60, 0xcf, 0xeb, 0x60, 0xb7,
+  0xfb, 0x1a, 0x2c, 0xa9, 0xfd, 0x6c, 0x16, 0xff,
+  0x63, 0x45, 0xa7, 0x3c, 0xdf, 0xec, 0x68, 0xb7,
+  0x27, 0xfe, 0x4c, 0x1c, 0xef, 0x2a, 0xe3, 0xe1,
+  0x3a, 0x04, 0xfb, 0xe8, 0x57, 0x3f, 0xef, 0x75,
+  0xb0, 0x5b, 0xfd, 0x8d, 0x14, 0x3c, 0xfd, 0xd5,
+  0xe6, 0x0a, 0x50, 0xe9, 0xff, 0xfb, 0x38, 0xaa,
+  0x73, 0xb6, 0xbb, 0xe0, 0xa5, 0x10, 0x05, 0x4a,
+  0xd8, 0x8f, 0x35, 0x10, 0xdc, 0x8c, 0xbe, 0x5f,
+  0x3f, 0xad, 0x82, 0xdf, 0xec, 0x68, 0xbc, 0xe1,
+  0x17, 0xea, 0x9c, 0x61, 0xc2, 0x96, 0x4b, 0x7c,
+  0x7e, 0x1e, 0x42, 0x4c, 0xa3, 0xba, 0x9d, 0xf6,
+  0x39, 0xd5, 0xc8, 0xd3, 0xfa, 0xd8, 0x2d, 0xfe,
+  0xc6, 0x8a, 0x5a, 0x7f, 0x5b, 0x05, 0xbf, 0xd8,
+  0xd1, 0x61, 0x4f, 0xeb, 0x60, 0xb7, 0xfb, 0x1a,
+  0x2c, 0xb9, 0xff, 0xd6, 0x57, 0xba, 0xd8, 0x2d,
+  0xfe, 0xc6, 0x8a, 0x32, 0x7f, 0x59, 0x17, 0x20,
+  0xa0, 0x0e, 0x87, 0x26, 0x6a, 0x27, 0x6a, 0x3b,
+  0xa1, 0xde, 0x94, 0xa7, 0xfe, 0xb7, 0xba, 0xd8,
+  0x2d, 0xfe, 0xc6, 0x88, 0xe6, 0x7f, 0xf5, 0x95,
+  0xee, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x72, 0x9f,
+  0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x59, 0x93, 0xfa,
+  0xd8, 0x2d, 0xfe, 0xc6, 0x8b, 0x76, 0x7f, 0xf5,
+  0x95, 0xee, 0xb6, 0x0b, 0x7f, 0xb1, 0xa2, 0x90,
+  0x9f, 0xfa, 0xde, 0xeb, 0x60, 0xb7, 0xfb, 0x1a,
+  0x25, 0x28, 0x79, 0x3b, 0x25, 0x93, 0x14, 0xa5,
+  0xd3, 0xbd, 0x1d, 0xde, 0x29, 0x4f, 0xfb, 0xdd,
+  0x6c, 0x16, 0xff, 0x63, 0x44, 0xed, 0x3f, 0xfe,
+  0xdf, 0x17, 0x29, 0x2f, 0x3f, 0x8e, 0xa7, 0x71,
+  0x8e, 0x99, 0x56, 0x52, 0x27, 0xfd, 0x1a, 0x7c,
+  0x2d, 0xfe, 0xc6, 0x88, 0xb2, 0x7f, 0xde, 0xeb,
+  0x60, 0xb7, 0xfb, 0x1a, 0x25, 0xd9, 0xff, 0xfb,
+  0x38, 0xaa, 0x73, 0xb6, 0xbb, 0xe0, 0xa5, 0x10,
+  0x05, 0x4a, 0xd8, 0x8d, 0x35, 0x18, 0x2f, 0xa3,
+  0x4f, 0xfe, 0xb2, 0xbd, 0xd6, 0xc1, 0x6f, 0xf6,
+  0x34, 0x4c, 0x53, 0xfa, 0xd8, 0x2d, 0xfe, 0xc6,
+  0x8a, 0xa6, 0x7f, 0xf5, 0x95, 0xee, 0xb6, 0x0b,
+  0x7f, 0xb1, 0xa2, 0x74, 0x9f, 0xdb, 0xf1, 0x47,
+  0x7a, 0xe3, 0xa7, 0xcb, 0x22, 0xc9, 0x43, 0xa7,
+  0xe0, 0xe6, 0xd7, 0x67, 0x4e, 0x9e, 0xdd, 0x52,
+  0xdb, 0x3d, 0x6a, 0x14, 0x4f, 0xfd, 0x75, 0x34,
+  0x8f, 0xda, 0xe5, 0xb6, 0xa3, 0xa1, 0x48, 0x82,
+  0xa9, 0xcc, 0xff, 0xbd, 0xd6, 0xc1, 0x6f, 0xf6,
+  0x34, 0x4e, 0xf3, 0xed, 0x5d, 0xea, 0xd9, 0x52,
+  0xb7, 0x09, 0xcd, 0xe4, 0x61, 0x4a, 0x23, 0xf4,
+  0x69, 0xff, 0xd6, 0x57, 0xba, 0xd8, 0x2d, 0xfe,
+  0xc6, 0x8a, 0x16, 0x7f, 0xf5, 0x95, 0xee, 0xb6,
+  0x0b, 0x7f, 0xb1, 0xa2, 0x92, 0x9f, 0xff, 0xd9,
+  0x4b, 0x73, 0xc5, 0xab, 0xea, 0xd5, 0x53, 0x57,
+  0x28, 0xe8, 0x79, 0x70, 0x0d, 0xc7, 0x0c, 0xa4,
+  0x27, 0x6a, 0x8f, 0xb4, 0x09, 0x37, 0x29, 0x2f,
+  0xa9, 0x4f, 0xeb, 0x60, 0xb7, 0xfb, 0x1a, 0x22,
+  0x49, 0xff, 0xd6, 0x57, 0xba, 0xd8, 0x2d, 0xfe,
+  0xc6, 0x89, 0x7a, 0x7c, 0x2d, 0xfe, 0xc6, 0x8a,
+  0x5e, 0x7f, 0x27, 0x17, 0x9b, 0x52, 0x50, 0xe9,
+  0x5b, 0x0f, 0x9b, 0x46, 0x13, 0xfa, 0xd8, 0x2d,
+  0xfe, 0xc6, 0x8a, 0x72, 0x7f, 0xdb, 0x1f, 0xa5,
+  0x73, 0x3a, 0xc7, 0x4f, 0xfb, 0x2a, 0x83, 0x96,
+  0x08, 0x42, 0x54, 0xdb, 0x09, 0xd3, 0x3d, 0x6e,
+  0x11, 0x1a, 0xbe, 0x77, 0x78, 0x79, 0x3e, 0x16,
+  0xff, 0x63, 0x45, 0x79, 0x3f, 0xff, 0x67, 0x15,
+  0x4e, 0x76, 0xd7, 0x7c, 0x14, 0xa2, 0x00, 0xa9,
+  0x5b, 0x11, 0x1a, 0xbe, 0x61, 0x3f, 0xf5, 0xbd,
+  0xd6, 0xc1, 0x6f, 0xf6, 0x34, 0x48, 0xf3, 0xb6,
+  0x04, 0x3a, 0x73, 0x62, 0x8a, 0xb1, 0x77, 0x3e,
+  0x16, 0xff, 0x63, 0x44, 0x91, 0x3d, 0x6f, 0x75,
+  0x90, 0xf6, 0x70, 0xa6, 0x7f, 0xeb, 0x7b, 0xad,
+  0x82, 0xdf, 0xec, 0x68, 0x92, 0xa7, 0xc2, 0xdf,
+  0xec, 0x68, 0xbc, 0x67, 0xeb, 0xba, 0xff, 0xbf,
+  0x43, 0xa7, 0xd4, 0xa6, 0xb1, 0x8e, 0x9f, 0xe7,
+  0x5b, 0x05, 0xbf, 0xd8, 0xd1, 0x26, 0xca, 0xd8,
+  0x8c, 0x77, 0xcc, 0x04, 0xc3, 0xc9, 0xa1, 0x17,
+  0x4a, 0x5e, 0x3b, 0x74, 0x2e, 0x38, 0x27, 0xdc,
+  0x32, 0x16, 0x86, 0x8a, 0x8a, 0xeb, 0x0c, 0x0d,
+  0x1b, 0xdd, 0x18, 0x9c, 0x24, 0x69, 0x1f, 0x6f,
+  0x47, 0x3a, 0xe8, 0xf2, 0x78, 0x8f, 0x6b, 0x2d,
+  0xb5, 0x2d, 0xf9, 0x4a, 0xcd, 0x5e, 0x95, 0x3f,
+  0x3c, 0x19, 0xb9, 0xcc, 0x4b, 0xdc, 0x76, 0x0b,
+  0x52, 0xc7, 0x06, 0x7e, 0xd9, 0x57, 0xf1, 0x51,
+  0x59, 0xda, 0x6f, 0xa6, 0xca, 0x02, 0x55, 0x92,
+  0xf7, 0x0b, 0x0e, 0xce, 0xd5, 0x52, 0x90, 0xff,
+  0xaa, 0xdb, 0x2a, 0xea, 0x4f, 0x52, 0xe8, 0xf5,
+  0x83, 0x1f, 0xe2, 0xfc, 0x3f, 0x39, 0xce, 0x82,
+  0x5e, 0x4e, 0xd3, 0x40,
 };
 
-static const unsigned kPreloadedHSTSBits = 83397;
+static const unsigned kPreloadedHSTSBits = 86044;
 
-static const unsigned kHSTSRootPosition = 82825;
+static const unsigned kHSTSRootPosition = 85472;
 
 #endif // NET_HTTP_TRANSPORT_SECURITY_STATE_STATIC_H_
diff --git a/net/http/transport_security_state_static.json b/net/http/transport_security_state_static.json
index 1f163aa..282cd58 100644
--- a/net/http/transport_security_state_static.json
+++ b/net/http/transport_security_state_static.json
@@ -1262,7 +1262,92 @@
     { "name": "tno.io", "include_subdomains": true, "mode": "force-https" },
     { "name": "translatoruk.co.uk", "include_subdomains": true, "mode": "force-https" },
     { "name": "wepay.in.th", "include_subdomains": true, "mode": "force-https" },
-    { "name": "zixiao.wang", "include_subdomains": true, "mode": "force-https" }
+    { "name": "zixiao.wang", "include_subdomains": true, "mode": "force-https" },
+
+    { "name": "at.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "au.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "az.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "be.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "bi.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "br.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ca.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "cd.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "cg.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "chfr.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "chit.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ch.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "cl.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "cn.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "co.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "cr.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ct.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "de.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "dk.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "do.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "en-maktoob.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "espanol.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "es.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "fi.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "fj.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "fr.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "gl.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "gm.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "gr.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "hk.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "hn.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "hu.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "id.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ie.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "in.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "it.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "kr.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "kz.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "li.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "lt.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "lu.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "lv.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "maktoob.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "malaysia.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "mt.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "mu.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "mw.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "mx.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ni.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "nl.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "no.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "np.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "nz.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "pa.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "pe.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ph.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "pk.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "pl.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "pr.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "py.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "qc.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ro.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ru.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "rw.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "se.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "sg.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "sv.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "th.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "tr.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "tv.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "tw.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ua.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "uk.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "uy.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "uz.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "ve.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "vn.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "xa.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "za.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "zh.search.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "login.yahoo.com", "include_subdomains": true, "mode": "force-https" },
+    { "name": "mail.yahoo.com", "include_subdomains": false, "mode": "force-https" },
+    { "name": "edit.yahoo.com", "include_subdomains": true, "mode": "force-https" }
   ],
 
   // |ReportUMAOnPinFailure| uses these to report which domain was associated
diff --git a/net/http/url_security_manager.h b/net/http/url_security_manager.h
index 4015fc2..2835d89 100644
--- a/net/http/url_security_manager.h
+++ b/net/http/url_security_manager.h
@@ -64,8 +64,8 @@
   virtual ~URLSecurityManagerWhitelist();
 
   // URLSecurityManager methods.
-  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const OVERRIDE;
-  virtual bool CanDelegate(const GURL& auth_origin) const OVERRIDE;
+  virtual bool CanUseDefaultCredentials(const GURL& auth_origin) const override;
+  virtual bool CanDelegate(const GURL& auth_origin) const override;
 
  private:
   scoped_ptr<const HttpAuthFilter> whitelist_default_;
diff --git a/net/net.gypi b/net/net.gypi
index 8ed69df..36aa3e6 100644
--- a/net/net.gypi
+++ b/net/net.gypi
@@ -189,6 +189,8 @@
       'base/bandwidth_metrics.cc',
       'base/bandwidth_metrics.h',
       'base/cache_type.h',
+      'base/chunked_upload_data_stream.cc',
+      'base/chunked_upload_data_stream.h',
       'base/crypto_module.h',
       'base/crypto_module_nss.cc',
       'base/crypto_module_openssl.cc',
@@ -198,6 +200,8 @@
       'base/directory_lister.h',
       'base/dns_reloader.cc',
       'base/dns_reloader.h',
+      'base/elements_upload_data_stream.cc',
+      'base/elements_upload_data_stream.h',
       'base/expiring_cache.h',
       'base/file_stream.cc',
       'base/file_stream.h',
@@ -1254,9 +1258,11 @@
       'base/address_list_unittest.cc',
       'base/address_tracker_linux_unittest.cc',
       'base/backoff_entry_unittest.cc',
+      'base/chunked_upload_data_stream_unittest.cc',
       'base/data_url_unittest.cc',
       'base/directory_lister_unittest.cc',
       'base/dns_util_unittest.cc',
+      'base/elements_upload_data_stream_unittest.cc',
       'base/escape_unittest.cc',
       'base/expiring_cache_unittest.cc',
       'base/file_stream_unittest.cc',
@@ -1285,7 +1291,6 @@
       'base/test_completion_callback_unittest.cc',
       'base/trace_net_log_observer_unittest.cc',
       'base/upload_bytes_element_reader_unittest.cc',
-      'base/upload_data_stream_unittest.cc',
       'base/upload_file_element_reader_unittest.cc',
       'base/url_util_unittest.cc',
       'cert/cert_verify_proc_unittest.cc',
diff --git a/net/net_unittests.isolate b/net/net_unittests.isolate
index dafa0d7..15b3f08 100644
--- a/net/net_unittests.isolate
+++ b/net/net_unittests.isolate
@@ -17,6 +17,8 @@
           '<(PRODUCT_DIR)/net_unittests<(EXECUTABLE_SUFFIX)',
           '--brave-new-test-launcher',
           '--test-launcher-bot-mode',
+          '--asan=<(asan)',
+          '--lsan=<(lsan)',
         ],
         'files': [
           '../testing/test_env.py',
diff --git a/net/ocsp/nss_ocsp.cc b/net/ocsp/nss_ocsp.cc
index 1d7fa9d..02eb2c7 100644
--- a/net/ocsp/nss_ocsp.cc
+++ b/net/ocsp/nss_ocsp.cc
@@ -30,12 +30,12 @@
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_data_stream.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/redirect_info.h"
@@ -285,7 +285,7 @@
 
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     DCHECK_EQ(request_.get(), request);
     DCHECK_EQ(base::MessageLoopForIO::current(), io_loop_);
 
@@ -296,7 +296,7 @@
     }
   }
 
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {
+  virtual void OnResponseStarted(URLRequest* request) override {
     DCHECK_EQ(request_.get(), request);
     DCHECK_EQ(base::MessageLoopForIO::current(), io_loop_);
 
@@ -311,7 +311,7 @@
   }
 
   virtual void OnReadCompleted(URLRequest* request,
-                               int bytes_read) OVERRIDE {
+                               int bytes_read) override {
     DCHECK_EQ(request_.get(), request);
     DCHECK_EQ(base::MessageLoopForIO::current(), io_loop_);
 
@@ -411,8 +411,8 @@
 
       scoped_ptr<UploadElementReader> reader(new UploadBytesElementReader(
           upload_content_.data(), upload_content_.size()));
-      request_->set_upload(make_scoped_ptr(
-          UploadDataStream::CreateWithReader(reader.Pass(), 0)));
+      request_->set_upload(
+          ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0));
     }
     if (!extra_request_headers_.IsEmpty())
       request_->SetExtraRequestHeaders(extra_request_headers_);
diff --git a/net/ocsp/nss_ocsp_unittest.cc b/net/ocsp/nss_ocsp_unittest.cc
index 0201ad1..3df446e 100644
--- a/net/ocsp/nss_ocsp_unittest.cc
+++ b/net/ocsp/nss_ocsp_unittest.cc
@@ -49,7 +49,7 @@
   // net::URLRequestInterceptor implementation:
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     ++const_cast<AiaResponseHandler*>(this)->request_count_;
 
     return new net::URLRequestTestJob(
diff --git a/net/proxy/dhcp_proxy_script_adapter_fetcher_win.cc b/net/proxy/dhcp_proxy_script_adapter_fetcher_win.cc
index b50b579..8d41d66 100644
--- a/net/proxy/dhcp_proxy_script_adapter_fetcher_win.cc
+++ b/net/proxy/dhcp_proxy_script_adapter_fetcher_win.cc
@@ -220,7 +220,6 @@
 
   DHCPCAPI_PARAMS_ARRAY send_params = { 0, NULL };
 
-  BYTE option_data[] = { 1, 252 };
   DHCPCAPI_PARAMS wpad_params = { 0 };
   wpad_params.OptionId = 252;
   wpad_params.IsVendor = FALSE;  // Surprising, but intentional.
diff --git a/net/proxy/dhcp_proxy_script_adapter_fetcher_win_unittest.cc b/net/proxy/dhcp_proxy_script_adapter_fetcher_win_unittest.cc
index 821e4eb..8e19001 100644
--- a/net/proxy/dhcp_proxy_script_adapter_fetcher_win_unittest.cc
+++ b/net/proxy/dhcp_proxy_script_adapter_fetcher_win_unittest.cc
@@ -51,7 +51,7 @@
     fetcher_ = NULL;
   }
 
-  virtual ProxyScriptFetcher* ImplCreateScriptFetcher() OVERRIDE {
+  virtual ProxyScriptFetcher* ImplCreateScriptFetcher() override {
     // We don't maintain ownership of the fetcher, it is transferred to
     // the caller.
     fetcher_ = new MockProxyScriptFetcher();
@@ -71,7 +71,7 @@
     }
 
     std::string ImplGetPacURLFromDhcp(
-        const std::string& adapter_name) OVERRIDE {
+        const std::string& adapter_name) override {
       base::ElapsedTimer timer;
       test_finished_event_.TimedWait(dhcp_delay_);
       return configured_url_;
@@ -82,7 +82,7 @@
     std::string configured_url_;
   };
 
-  virtual DhcpQuery* ImplCreateDhcpQuery() OVERRIDE {
+  virtual DhcpQuery* ImplCreateDhcpQuery() override {
     dhcp_query_ = new DelayingDhcpQuery();
     dhcp_query_->dhcp_delay_ = dhcp_delay_;
     dhcp_query_->configured_url_ = configured_url_;
@@ -90,7 +90,7 @@
   }
 
   // Use a shorter timeout so tests can finish more quickly.
-  virtual base::TimeDelta ImplGetTimeout() const OVERRIDE {
+  virtual base::TimeDelta ImplGetTimeout() const override {
     return timeout_;
   }
 
@@ -272,7 +272,7 @@
   }
 
   // Returns a real proxy script fetcher.
-  ProxyScriptFetcher* ImplCreateScriptFetcher() OVERRIDE {
+  ProxyScriptFetcher* ImplCreateScriptFetcher() override {
     ProxyScriptFetcher* fetcher =
         new ProxyScriptFetcherImpl(url_request_context_);
     return fetcher;
diff --git a/net/proxy/dhcp_proxy_script_fetcher.h b/net/proxy/dhcp_proxy_script_fetcher.h
index 0ec2ed4..bb293de 100644
--- a/net/proxy/dhcp_proxy_script_fetcher.h
+++ b/net/proxy/dhcp_proxy_script_fetcher.h
@@ -86,9 +86,9 @@
   virtual ~DoNothingDhcpProxyScriptFetcher();
 
   virtual int Fetch(base::string16* utf16_text,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
-  virtual const GURL& GetPacURL() const OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual void Cancel() override;
+  virtual const GURL& GetPacURL() const override;
  private:
   GURL gurl_;
   DISALLOW_COPY_AND_ASSIGN(DoNothingDhcpProxyScriptFetcher);
diff --git a/net/proxy/dhcp_proxy_script_fetcher_win.h b/net/proxy/dhcp_proxy_script_fetcher_win.h
index d6f14f9..1122997 100644
--- a/net/proxy/dhcp_proxy_script_fetcher_win.h
+++ b/net/proxy/dhcp_proxy_script_fetcher_win.h
@@ -39,10 +39,10 @@
 
   // DhcpProxyScriptFetcher implementation.
   int Fetch(base::string16* utf16_text,
-            const net::CompletionCallback& callback) OVERRIDE;
-  void Cancel() OVERRIDE;
-  const GURL& GetPacURL() const OVERRIDE;
-  std::string GetFetcherName() const OVERRIDE;
+            const net::CompletionCallback& callback) override;
+  void Cancel() override;
+  const GURL& GetPacURL() const override;
+  std::string GetFetcherName() const override;
 
   // Sets |adapter_names| to contain the name of each network adapter on
   // this machine that has DHCP enabled and is not a loop-back adapter. Returns
diff --git a/net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc b/net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc
index 743fb26..eb98330 100644
--- a/net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc
+++ b/net/proxy/dhcp_proxy_script_fetcher_win_unittest.cc
@@ -169,13 +169,13 @@
     }
 
     std::string ImplGetPacURLFromDhcp(
-        const std::string& adapter_name) OVERRIDE {
+        const std::string& adapter_name) override {
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
       return DhcpQuery::ImplGetPacURLFromDhcp(adapter_name);
     }
   };
 
-  DhcpQuery* ImplCreateDhcpQuery() OVERRIDE {
+  DhcpQuery* ImplCreateDhcpQuery() override {
     return new DelayingDhcpQuery();
   }
 };
@@ -189,7 +189,7 @@
       : DhcpProxyScriptFetcherWin(context) {
   }
 
-  DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
+  DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() override {
     return new DelayingDhcpProxyScriptAdapterFetcher(url_request_context(),
                                                      GetTaskRunner());
   }
@@ -224,25 +224,25 @@
   }
 
   void Fetch(const std::string& adapter_name,
-             const CompletionCallback& callback) OVERRIDE {
+             const CompletionCallback& callback) override {
     callback_ = callback;
     timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(fetch_delay_ms_),
                  this, &DummyDhcpProxyScriptAdapterFetcher::OnTimer);
   }
 
-  void Cancel() OVERRIDE {
+  void Cancel() override {
     timer_.Stop();
   }
 
-  bool DidFinish() const OVERRIDE {
+  bool DidFinish() const override {
     return did_finish_;
   }
 
-  int GetResult() const OVERRIDE {
+  int GetResult() const override {
     return result_;
   }
 
-  base::string16 GetPacScript() const OVERRIDE {
+  base::string16 GetPacScript() const override {
     return pac_script_;
   }
 
@@ -280,7 +280,7 @@
     }
 
     virtual bool ImplGetCandidateAdapterNames(
-        std::set<std::string>* adapter_names) OVERRIDE {
+        std::set<std::string>* adapter_names) override {
       adapter_names->insert(
           mock_adapter_names_.begin(), mock_adapter_names_.end());
       return true;
@@ -324,21 +324,21 @@
     PushBackAdapter(adapter_name, adapter_fetcher.release());
   }
 
-  DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() OVERRIDE {
+  DhcpProxyScriptAdapterFetcher* ImplCreateAdapterFetcher() override {
     ++num_fetchers_created_;
     return adapter_fetchers_[next_adapter_fetcher_index_++];
   }
 
-  virtual AdapterQuery* ImplCreateAdapterQuery() OVERRIDE {
+  virtual AdapterQuery* ImplCreateAdapterQuery() override {
     DCHECK(adapter_query_);
     return adapter_query_.get();
   }
 
-  base::TimeDelta ImplGetMaxWait() OVERRIDE {
+  base::TimeDelta ImplGetMaxWait() override {
     return max_wait_;
   }
 
-  void ImplOnGetCandidateAdapterNamesDone() OVERRIDE {
+  void ImplOnGetCandidateAdapterNamesDone() override {
     worker_finished_event_.Signal();
   }
 
diff --git a/net/proxy/mock_proxy_resolver.h b/net/proxy/mock_proxy_resolver.h
index 3864d53..5a616dd 100644
--- a/net/proxy/mock_proxy_resolver.h
+++ b/net/proxy/mock_proxy_resolver.h
@@ -77,13 +77,13 @@
                              ProxyInfo* results,
                              const net::CompletionCallback& callback,
                              RequestHandle* request_handle,
-                             const BoundNetLog& /*net_log*/) OVERRIDE;
-  virtual void CancelRequest(RequestHandle request_handle) OVERRIDE;
-  virtual LoadState GetLoadState(RequestHandle request_handle) const OVERRIDE;
+                             const BoundNetLog& /*net_log*/) override;
+  virtual void CancelRequest(RequestHandle request_handle) override;
+  virtual LoadState GetLoadState(RequestHandle request_handle) const override;
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const net::CompletionCallback& callback) OVERRIDE;
-  virtual void CancelSetPacScript() OVERRIDE;
+      const net::CompletionCallback& callback) override;
+  virtual void CancelSetPacScript() override;
 
   const RequestsList& pending_requests() const {
     return pending_requests_;
diff --git a/net/proxy/mock_proxy_script_fetcher.h b/net/proxy/mock_proxy_script_fetcher.h
index 81e221f..910c6b2 100644
--- a/net/proxy/mock_proxy_script_fetcher.h
+++ b/net/proxy/mock_proxy_script_fetcher.h
@@ -25,9 +25,9 @@
   // ProxyScriptFetcher implementation.
   virtual int Fetch(const GURL& url,
                     base::string16* text,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
-  virtual URLRequestContext* GetRequestContext() const OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual void Cancel() override;
+  virtual URLRequestContext* GetRequestContext() const override;
 
   void NotifyFetchCompletion(int result, const std::string& ascii_text);
   const GURL& pending_request_url() const;
diff --git a/net/proxy/multi_threaded_proxy_resolver.cc b/net/proxy/multi_threaded_proxy_resolver.cc
index 4b68321..a2a6515 100644
--- a/net/proxy/multi_threaded_proxy_resolver.cc
+++ b/net/proxy/multi_threaded_proxy_resolver.cc
@@ -175,7 +175,7 @@
   }
 
   // Runs on the worker thread.
-  virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE {
+  virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) override {
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->SetPacScript(script_data_, CompletionCallback());
 
@@ -222,12 +222,12 @@
 
   BoundNetLog* net_log() { return &net_log_; }
 
-  virtual void WaitingForThread() OVERRIDE {
+  virtual void WaitingForThread() override {
     was_waiting_for_thread_ = true;
     net_log_.BeginEvent(NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD);
   }
 
-  virtual void FinishedWaitingForThread() OVERRIDE {
+  virtual void FinishedWaitingForThread() override {
     DCHECK(executor());
 
     if (was_waiting_for_thread_) {
@@ -240,7 +240,7 @@
   }
 
   // Runs on the worker thread.
-  virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE {
+  virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) override {
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->GetProxyForURL(
         url_, &results_buf_, CompletionCallback(), NULL, net_log_);
diff --git a/net/proxy/multi_threaded_proxy_resolver.h b/net/proxy/multi_threaded_proxy_resolver.h
index 5c470f4..0a14461 100644
--- a/net/proxy/multi_threaded_proxy_resolver.h
+++ b/net/proxy/multi_threaded_proxy_resolver.h
@@ -95,13 +95,13 @@
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle request) OVERRIDE;
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE;
-  virtual void CancelSetPacScript() OVERRIDE;
+                             const BoundNetLog& net_log) override;
+  virtual void CancelRequest(RequestHandle request) override;
+  virtual LoadState GetLoadState(RequestHandle request) const override;
+  virtual void CancelSetPacScript() override;
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
 
  private:
   class Executor;
diff --git a/net/proxy/multi_threaded_proxy_resolver_unittest.cc b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
index e1c9e90..d2e465c 100644
--- a/net/proxy/multi_threaded_proxy_resolver_unittest.cc
+++ b/net/proxy/multi_threaded_proxy_resolver_unittest.cc
@@ -40,7 +40,7 @@
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     if (resolve_latency_ != base::TimeDelta())
       base::PlatformThread::Sleep(resolve_latency_);
 
@@ -58,22 +58,22 @@
     return request_count_++;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
+  virtual void CancelRequest(RequestHandle request) override {
     NOTREACHED();
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
+  virtual LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
+  virtual void CancelSetPacScript() override {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     CheckIsOnWorkerThread();
     last_script_data_ = script_data;
     return OK;
@@ -137,7 +137,7 @@
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     if (should_block_) {
       blocked_.Signal();
       unblocked_.Wait();
@@ -164,27 +164,27 @@
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     return impl_->GetProxyForURL(
         query_url, results, callback, request, net_log);
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
+  virtual void CancelRequest(RequestHandle request) override {
     impl_->CancelRequest(request);
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
+  virtual LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
+  virtual void CancelSetPacScript() override {
     impl_->CancelSetPacScript();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     return impl_->SetPacScript(script_data, callback);
   }
 
@@ -200,7 +200,7 @@
       : ProxyResolverFactory(resolver->expects_pac_bytes()),
         resolver_(resolver) {}
 
-  virtual ProxyResolver* CreateProxyResolver() OVERRIDE {
+  virtual ProxyResolver* CreateProxyResolver() override {
     return new ForwardingProxyResolver(resolver_);
   }
 
@@ -217,7 +217,7 @@
     STLDeleteElements(&resolvers_);
   }
 
-  virtual ProxyResolver* CreateProxyResolver() OVERRIDE {
+  virtual ProxyResolver* CreateProxyResolver() override {
     BlockableProxyResolver* resolver = new BlockableProxyResolver;
     resolvers_.push_back(resolver);
     return new ForwardingProxyResolver(resolver);
diff --git a/net/proxy/network_delegate_error_observer.h b/net/proxy/network_delegate_error_observer.h
index e4b03aa..70a2bed 100644
--- a/net/proxy/network_delegate_error_observer.h
+++ b/net/proxy/network_delegate_error_observer.h
@@ -28,7 +28,7 @@
 
   // ProxyResolverErrorObserver implementation.
   virtual void OnPACScriptError(int line_number, const base::string16& error)
-      OVERRIDE;
+      override;
 
  private:
   class Core;
diff --git a/net/proxy/network_delegate_error_observer_unittest.cc b/net/proxy/network_delegate_error_observer_unittest.cc
index 1f6330f..8547761 100644
--- a/net/proxy/network_delegate_error_observer_unittest.cc
+++ b/net/proxy/network_delegate_error_observer_unittest.cc
@@ -27,62 +27,62 @@
   // net::NetworkDelegate implementation.
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE {
+                                 GURL* new_url) override {
     return OK;
   }
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
-                                  HttpRequestHeaders* headers) OVERRIDE {
+                                  HttpRequestHeaders* headers) override {
     return OK;
   }
   virtual void OnSendHeaders(URLRequest* request,
-                             const HttpRequestHeaders& headers) OVERRIDE {}
+                             const HttpRequestHeaders& headers) override {}
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE {
+      GURL* allowed_unsafe_redirect_url) override {
     return net::OK;
   }
   virtual void OnBeforeRedirect(URLRequest* request,
-                                const GURL& new_location) OVERRIDE {}
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {}
+                                const GURL& new_location) override {}
+  virtual void OnResponseStarted(URLRequest* request) override {}
   virtual void OnRawBytesRead(const URLRequest& request,
-                              int bytes_read) OVERRIDE {}
-  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE {}
-  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE {}
+                              int bytes_read) override {}
+  virtual void OnCompleted(URLRequest* request, bool started) override {}
+  virtual void OnURLRequestDestroyed(URLRequest* request) override {}
 
   virtual void OnPACScriptError(int line_number,
-                                const base::string16& error) OVERRIDE {
+                                const base::string16& error) override {
     got_pac_error_ = true;
   }
   virtual AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE {
+      AuthCredentials* credentials) override {
     return AUTH_REQUIRED_RESPONSE_NO_ACTION;
   }
   virtual bool OnCanGetCookies(const URLRequest& request,
-                               const CookieList& cookie_list) OVERRIDE {
+                               const CookieList& cookie_list) override {
     return true;
   }
   virtual bool OnCanSetCookie(const URLRequest& request,
                               const std::string& cookie_line,
-                              CookieOptions* options) OVERRIDE {
+                              CookieOptions* options) override {
     return true;
   }
   virtual bool OnCanAccessFile(const net::URLRequest& request,
-                               const base::FilePath& path) const OVERRIDE {
+                               const base::FilePath& path) const override {
     return true;
   }
-  virtual bool OnCanThrottleRequest(const URLRequest& request) const OVERRIDE {
+  virtual bool OnCanThrottleRequest(const URLRequest& request) const override {
     return false;
   }
   virtual int OnBeforeSocketStreamConnect(
       SocketStream* stream,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     return OK;
   }
 
diff --git a/net/proxy/polling_proxy_config_service.h b/net/proxy/polling_proxy_config_service.h
index f5f5117..dc0db48 100644
--- a/net/proxy/polling_proxy_config_service.h
+++ b/net/proxy/polling_proxy_config_service.h
@@ -20,10 +20,10 @@
 class NET_EXPORT_PRIVATE PollingProxyConfigService : public ProxyConfigService {
  public:
   // ProxyConfigService implementation:
-  virtual void AddObserver(Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(Observer* observer) OVERRIDE;
-  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) OVERRIDE;
-  virtual void OnLazyPoll() OVERRIDE;
+  virtual void AddObserver(Observer* observer) override;
+  virtual void RemoveObserver(Observer* observer) override;
+  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) override;
+  virtual void OnLazyPoll() override;
 
  protected:
   // Function for retrieving the current proxy configuration.
diff --git a/net/proxy/proxy_bypass_rules.cc b/net/proxy/proxy_bypass_rules.cc
index 239a2fe..debb2e8 100644
--- a/net/proxy/proxy_bypass_rules.cc
+++ b/net/proxy/proxy_bypass_rules.cc
@@ -27,7 +27,7 @@
         optional_port_(optional_port) {
   }
 
-  virtual bool Matches(const GURL& url) const OVERRIDE {
+  virtual bool Matches(const GURL& url) const override {
     if (optional_port_ != -1 && url.EffectiveIntPort() != optional_port_)
       return false;  // Didn't match port expectation.
 
@@ -40,7 +40,7 @@
                         hostname_pattern_);
   }
 
-  virtual std::string ToString() const OVERRIDE {
+  virtual std::string ToString() const override {
     std::string str;
     if (!optional_scheme_.empty())
       base::StringAppendF(&str, "%s://", optional_scheme_.c_str());
@@ -50,7 +50,7 @@
     return str;
   }
 
-  virtual Rule* Clone() const OVERRIDE {
+  virtual Rule* Clone() const override {
     return new HostnamePatternRule(optional_scheme_,
                                    hostname_pattern_,
                                    optional_port_);
@@ -64,18 +64,18 @@
 
 class BypassLocalRule : public ProxyBypassRules::Rule {
  public:
-  virtual bool Matches(const GURL& url) const OVERRIDE {
+  virtual bool Matches(const GURL& url) const override {
     const std::string& host = url.host();
     if (host == "127.0.0.1" || host == "[::1]")
       return true;
     return host.find('.') == std::string::npos;
   }
 
-  virtual std::string ToString() const OVERRIDE {
+  virtual std::string ToString() const override {
     return "<local>";
   }
 
-  virtual Rule* Clone() const OVERRIDE {
+  virtual Rule* Clone() const override {
     return new BypassLocalRule();
   }
 };
@@ -96,7 +96,7 @@
         prefix_length_in_bits_(prefix_length_in_bits) {
   }
 
-  virtual bool Matches(const GURL& url) const OVERRIDE {
+  virtual bool Matches(const GURL& url) const override {
     if (!url.HostIsIPAddress())
       return false;
 
@@ -113,11 +113,11 @@
                                  prefix_length_in_bits_);
   }
 
-  virtual std::string ToString() const OVERRIDE {
+  virtual std::string ToString() const override {
     return description_;
   }
 
-  virtual Rule* Clone() const OVERRIDE {
+  virtual Rule* Clone() const override {
     return new BypassIPBlockRule(description_,
                                  optional_scheme_,
                                  ip_prefix_,
diff --git a/net/proxy/proxy_config_service_android.cc b/net/proxy/proxy_config_service_android.cc
index d27bc5a..f1a0b6c 100644
--- a/net/proxy/proxy_config_service_android.cc
+++ b/net/proxy/proxy_config_service_android.cc
@@ -6,6 +6,7 @@
 
 #include <sys/system_properties.h>
 
+#include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ -162,6 +163,7 @@
 void CreateStaticProxyConfig(const std::string& host,
                              int port,
                              const std::string& pac_url,
+                             const std::vector<std::string>& exclusion_list,
                              ProxyConfig* config) {
   if (!pac_url.empty()) {
     config->set_pac_url(GURL(pac_url));
@@ -169,6 +171,16 @@
   } else if (port != 0) {
     std::string rules = base::StringPrintf("%s:%d", host.c_str(), port);
     config->proxy_rules().ParseFromString(rules);
+    config->proxy_rules().bypass_rules.Clear();
+
+    std::vector<std::string>::const_iterator it;
+    for (it = exclusion_list.begin(); it != exclusion_list.end(); ++it) {
+      std::string pattern;
+      base::TrimWhitespaceASCII(*it, base::TRIM_ALL, &pattern);
+      if (pattern.empty())
+          continue;
+      config->proxy_rules().bypass_rules.AddRuleForHostname("", pattern, -1);
+    }
   } else {
     *config = ProxyConfig::CreateDirect();
   }
@@ -255,10 +267,11 @@
   // Called on the JNI thread.
   void ProxySettingsChangedTo(const std::string& host,
                               int port,
-                              const std::string& pac_url) {
+                              const std::string& pac_url,
+                              const std::vector<std::string>& exclusion_list) {
     DCHECK(OnJNIThread());
     ProxyConfig proxy_config;
-    CreateStaticProxyConfig(host, port, pac_url, &proxy_config);
+    CreateStaticProxyConfig(host, port, pac_url, exclusion_list, &proxy_config);
     network_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
@@ -277,15 +290,19 @@
                                         jobject jself,
                                         jstring jhost,
                                         jint jport,
-                                        jstring jpac_url) OVERRIDE {
+                                        jstring jpac_url,
+                                        jobjectArray jexclusion_list) override {
       std::string host = ConvertJavaStringToUTF8(env, jhost);
       std::string pac_url;
       if (jpac_url)
         ConvertJavaStringToUTF8(env, jpac_url, &pac_url);
-      delegate_->ProxySettingsChangedTo(host, jport, pac_url);
+      std::vector<std::string> exclusion_list;
+      base::android::AppendJavaStringArrayToStringVector(
+          env, jexclusion_list, &exclusion_list);
+      delegate_->ProxySettingsChangedTo(host, jport, pac_url, exclusion_list);
     }
 
-    virtual void ProxySettingsChanged(JNIEnv* env, jobject self) OVERRIDE {
+    virtual void ProxySettingsChanged(JNIEnv* env, jobject self) override {
       delegate_->ProxySettingsChanged();
     }
 
diff --git a/net/proxy/proxy_config_service_android.h b/net/proxy/proxy_config_service_android.h
index ee54b94..d642d37 100644
--- a/net/proxy/proxy_config_service_android.h
+++ b/net/proxy/proxy_config_service_android.h
@@ -42,11 +42,13 @@
     // changed. The string and int arguments (the host/port pair for the proxy)
     // are either a host/port pair or ("", 0) to indicate "no proxy".
     // The third argument indicates the PAC url.
+    // The fourth argument is the proxy exclusion list.
     virtual void ProxySettingsChangedTo(JNIEnv*,
                                         jobject,
                                         jstring,
                                         jint,
-                                        jstring) = 0;
+                                        jstring,
+                                        jobjectArray) = 0;
 
     // Called from Java (on JNI thread) to signal that the proxy settings have
     // changed. New proxy settings are fetched from the system property store.
@@ -64,9 +66,9 @@
 
   // ProxyConfigService:
   // Called only on the network thread.
-  virtual void AddObserver(Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(Observer* observer) OVERRIDE;
-  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) OVERRIDE;
+  virtual void AddObserver(Observer* observer) override;
+  virtual void RemoveObserver(Observer* observer) override;
+  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) override;
 
  private:
   friend class ProxyConfigServiceAndroidTestBase;
diff --git a/net/proxy/proxy_config_service_android_unittest.cc b/net/proxy/proxy_config_service_android_unittest.cc
index 03324b9..41f2387 100644
--- a/net/proxy/proxy_config_service_android_unittest.cc
+++ b/net/proxy/proxy_config_service_android_unittest.cc
@@ -25,7 +25,7 @@
   // ProxyConfigService::Observer:
   virtual void OnProxyConfigChanged(
       const ProxyConfig& config,
-      ProxyConfigService::ConfigAvailability availability) OVERRIDE {
+      ProxyConfigService::ConfigAvailability availability) override {
     config_ = config;
     availability_ = availability;
   }
@@ -62,12 +62,12 @@
   virtual ~ProxyConfigServiceAndroidTestBase() {}
 
   // testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     message_loop_->RunUntilIdle();
     service_.AddObserver(&observer_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     service_.RemoveObserver(&observer_);
   }
 
diff --git a/net/proxy/proxy_config_service_fixed.h b/net/proxy/proxy_config_service_fixed.h
index b5f30e3..14185c6 100644
--- a/net/proxy/proxy_config_service_fixed.h
+++ b/net/proxy/proxy_config_service_fixed.h
@@ -19,9 +19,9 @@
   virtual ~ProxyConfigServiceFixed();
 
   // ProxyConfigService methods:
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
-  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) OVERRIDE;
+  virtual void AddObserver(Observer* observer) override {}
+  virtual void RemoveObserver(Observer* observer) override {}
+  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) override;
 
  private:
   ProxyConfig pc_;
diff --git a/net/proxy/proxy_config_service_linux.cc b/net/proxy/proxy_config_service_linux.cc
index 4e9065e..145312e 100644
--- a/net/proxy/proxy_config_service_linux.cc
+++ b/net/proxy/proxy_config_service_linux.cc
@@ -235,7 +235,7 @@
   virtual bool Init(
       const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
-      OVERRIDE {
+      override {
     DCHECK(glib_task_runner->BelongsToCurrentThread());
     DCHECK(!client_);
     DCHECK(!task_runner_.get());
@@ -273,7 +273,7 @@
     return true;
   }
 
-  virtual void ShutDown() OVERRIDE {
+  virtual void ShutDown() override {
     if (client_) {
       DCHECK(task_runner_->BelongsToCurrentThread());
       // We must explicitly disable gconf notifications here, because the gconf
@@ -291,7 +291,7 @@
   }
 
   virtual bool SetUpNotifications(
-      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
+      ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
     GError* error = NULL;
@@ -321,15 +321,15 @@
   }
 
   virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() OVERRIDE {
+  GetNotificationTaskRunner() override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+  virtual ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GCONF;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
+  virtual bool GetString(StringSetting key, std::string* result) override {
     switch (key) {
       case PROXY_MODE:
         return GetStringByPath("/system/proxy/mode", result);
@@ -346,7 +346,7 @@
     }
     return false;  // Placate compiler.
   }
-  virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
+  virtual bool GetBool(BoolSetting key, bool* result) override {
     switch (key) {
       case PROXY_USE_HTTP_PROXY:
         return GetBoolByPath("/system/http_proxy/use_http_proxy", result);
@@ -357,7 +357,7 @@
     }
     return false;  // Placate compiler.
   }
-  virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
+  virtual bool GetInt(IntSetting key, int* result) override {
     switch (key) {
       case PROXY_HTTP_PORT:
         return GetIntByPath("/system/http_proxy/port", result);
@@ -371,7 +371,7 @@
     return false;  // Placate compiler.
   }
   virtual bool GetStringList(StringListSetting key,
-                             std::vector<std::string>* result) OVERRIDE {
+                             std::vector<std::string>* result) override {
     switch (key) {
       case PROXY_IGNORE_HOSTS:
         return GetStringListByPath("/system/http_proxy/ignore_hosts", result);
@@ -379,12 +379,12 @@
     return false;  // Placate compiler.
   }
 
-  virtual bool BypassListIsReversed() OVERRIDE {
+  virtual bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
+  virtual bool MatchHostsUsingSuffixMatching() override {
     return false;
   }
 
@@ -568,7 +568,7 @@
   virtual bool Init(
       const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
-      OVERRIDE {
+      override {
     DCHECK(glib_task_runner->BelongsToCurrentThread());
     DCHECK(!client_);
     DCHECK(!task_runner_.get());
@@ -589,7 +589,7 @@
     return true;
   }
 
-  virtual void ShutDown() OVERRIDE {
+  virtual void ShutDown() override {
     if (client_) {
       DCHECK(task_runner_->BelongsToCurrentThread());
       // This also disables gsettings notifications.
@@ -605,7 +605,7 @@
   }
 
   virtual bool SetUpNotifications(
-      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
+      ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK(client_);
     DCHECK(task_runner_->BelongsToCurrentThread());
     notify_delegate_ = delegate;
@@ -628,15 +628,15 @@
   }
 
   virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() OVERRIDE {
+  GetNotificationTaskRunner() override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+  virtual ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_GSETTINGS;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
+  virtual bool GetString(StringSetting key, std::string* result) override {
     DCHECK(client_);
     switch (key) {
       case PROXY_MODE:
@@ -654,7 +654,7 @@
     }
     return false;  // Placate compiler.
   }
-  virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
+  virtual bool GetBool(BoolSetting key, bool* result) override {
     DCHECK(client_);
     switch (key) {
       case PROXY_USE_HTTP_PROXY:
@@ -672,7 +672,7 @@
     }
     return false;  // Placate compiler.
   }
-  virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
+  virtual bool GetInt(IntSetting key, int* result) override {
     DCHECK(client_);
     switch (key) {
       case PROXY_HTTP_PORT:
@@ -687,7 +687,7 @@
     return false;  // Placate compiler.
   }
   virtual bool GetStringList(StringListSetting key,
-                             std::vector<std::string>* result) OVERRIDE {
+                             std::vector<std::string>* result) override {
     DCHECK(client_);
     switch (key) {
       case PROXY_IGNORE_HOSTS:
@@ -696,12 +696,12 @@
     return false;  // Placate compiler.
   }
 
-  virtual bool BypassListIsReversed() OVERRIDE {
+  virtual bool BypassListIsReversed() override {
     // This is a KDE-specific setting.
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
+  virtual bool MatchHostsUsingSuffixMatching() override {
     return false;
   }
 
@@ -932,7 +932,7 @@
   virtual bool Init(
       const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
-      OVERRIDE {
+      override {
     // This has to be called on the UI thread (http://crbug.com/69057).
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     DCHECK(inotify_fd_ < 0);
@@ -956,7 +956,7 @@
     return true;
   }
 
-  virtual void ShutDown() OVERRIDE {
+  virtual void ShutDown() override {
     if (inotify_fd_ >= 0) {
       ResetCachedSettings();
       inotify_watcher_.StopWatchingFileDescriptor();
@@ -966,7 +966,7 @@
   }
 
   virtual bool SetUpNotifications(
-      ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
+      ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK(inotify_fd_ >= 0);
     DCHECK(file_task_runner_->BelongsToCurrentThread());
     // We can't just watch the kioslaverc file directly, since KDE will write
@@ -990,41 +990,41 @@
   }
 
   virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() OVERRIDE {
+  GetNotificationTaskRunner() override {
     return file_task_runner_;
   }
 
   // Implement base::MessagePumpLibevent::Watcher.
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
+  virtual void OnFileCanReadWithoutBlocking(int fd) override {
     DCHECK_EQ(fd, inotify_fd_);
     DCHECK(file_task_runner_->BelongsToCurrentThread());
     OnChangeNotification();
   }
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override {
     NOTREACHED();
   }
 
-  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+  virtual ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_KDE;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
+  virtual bool GetString(StringSetting key, std::string* result) override {
     string_map_type::iterator it = string_table_.find(key);
     if (it == string_table_.end())
       return false;
     *result = it->second;
     return true;
   }
-  virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
+  virtual bool GetBool(BoolSetting key, bool* result) override {
     // We don't ever have any booleans.
     return false;
   }
-  virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
+  virtual bool GetInt(IntSetting key, int* result) override {
     // We don't ever have any integers. (See AddProxy() below about ports.)
     return false;
   }
   virtual bool GetStringList(StringListSetting key,
-                             std::vector<std::string>* result) OVERRIDE {
+                             std::vector<std::string>* result) override {
     strings_map_type::iterator it = strings_table_.find(key);
     if (it == strings_table_.end())
       return false;
@@ -1032,11 +1032,11 @@
     return true;
   }
 
-  virtual bool BypassListIsReversed() OVERRIDE {
+  virtual bool BypassListIsReversed() override {
     return reversed_bypass_list_;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
+  virtual bool MatchHostsUsingSuffixMatching() override {
     return true;
   }
 
diff --git a/net/proxy/proxy_config_service_linux.h b/net/proxy/proxy_config_service_linux.h
index fa7bd45..a8438c2 100644
--- a/net/proxy/proxy_config_service_linux.h
+++ b/net/proxy/proxy_config_service_linux.h
@@ -296,10 +296,10 @@
 
   // ProxyConfigService methods:
   // Called from IO thread.
-  virtual void AddObserver(Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(Observer* observer) OVERRIDE;
+  virtual void AddObserver(Observer* observer) override;
+  virtual void RemoveObserver(Observer* observer) override;
   virtual ProxyConfigService::ConfigAvailability GetLatestProxyConfig(
-      ProxyConfig* config) OVERRIDE;
+      ProxyConfig* config) override;
 
  private:
   scoped_refptr<Delegate> delegate_;
diff --git a/net/proxy/proxy_config_service_linux_unittest.cc b/net/proxy/proxy_config_service_linux_unittest.cc
index 5ca0fdc..cfb0cff 100644
--- a/net/proxy/proxy_config_service_linux_unittest.cc
+++ b/net/proxy/proxy_config_service_linux_unittest.cc
@@ -107,7 +107,7 @@
   }
 
   // Begin base::Environment implementation.
-  virtual bool GetVar(const char* variable_name, std::string* result) OVERRIDE {
+  virtual bool GetVar(const char* variable_name, std::string* result) override {
     std::map<std::string, const char**>::iterator it =
         table.find(variable_name);
     if (it != table.end() && *(it->second) != NULL) {
@@ -119,12 +119,12 @@
   }
 
   virtual bool SetVar(const char* variable_name, const std::string& new_value)
-      OVERRIDE {
+      override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool UnSetVar(const char* variable_name) OVERRIDE {
+  virtual bool UnSetVar(const char* variable_name) override {
     ADD_FAILURE();
     return false;
   }
@@ -178,28 +178,28 @@
   virtual bool Init(
       const scoped_refptr<base::SingleThreadTaskRunner>& glib_task_runner,
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
-      OVERRIDE {
+      override {
     task_runner_ = glib_task_runner;
     return true;
   }
 
-  virtual void ShutDown() OVERRIDE {}
+  virtual void ShutDown() override {}
 
   virtual bool SetUpNotifications(ProxyConfigServiceLinux::Delegate* delegate)
-      OVERRIDE {
+      override {
     return true;
   }
 
   virtual const scoped_refptr<base::SingleThreadTaskRunner>&
-  GetNotificationTaskRunner() OVERRIDE {
+  GetNotificationTaskRunner() override {
     return task_runner_;
   }
 
-  virtual ProxyConfigSource GetConfigSource() OVERRIDE {
+  virtual ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_TEST;
   }
 
-  virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
+  virtual bool GetString(StringSetting key, std::string* result) override {
     const char* value = strings_table.Get(key);
     if (value) {
       *result = value;
@@ -208,7 +208,7 @@
     return false;
   }
 
-  virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
+  virtual bool GetBool(BoolSetting key, bool* result) override {
     BoolSettingValue value = bools_table.Get(key);
     switch (value) {
     case UNSET:
@@ -222,24 +222,24 @@
     return true;
   }
 
-  virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
+  virtual bool GetInt(IntSetting key, int* result) override {
     // We don't bother to distinguish unset keys from 0 values.
     *result = ints_table.Get(key);
     return true;
   }
 
   virtual bool GetStringList(StringListSetting key,
-                             std::vector<std::string>* result) OVERRIDE {
+                             std::vector<std::string>* result) override {
     *result = string_lists_table.Get(key);
     // We don't bother to distinguish unset keys from empty lists.
     return !result->empty();
   }
 
-  virtual bool BypassListIsReversed() OVERRIDE {
+  virtual bool BypassListIsReversed() override {
     return false;
   }
 
-  virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
+  virtual bool MatchHostsUsingSuffixMatching() override {
     return false;
   }
 
@@ -355,7 +355,7 @@
 // must use the same test fixture class (also "ProxyConfigServiceLinuxTest").
 class ProxyConfigServiceLinuxTest : public PlatformTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     PlatformTest::SetUp();
     // Set up a temporary KDE home directory.
     std::string prefix("ProxyConfigServiceLinuxTest_user_home");
@@ -372,7 +372,7 @@
     kioslaverc4_ = kde4_config_.Append(FILE_PATH_LITERAL("kioslaverc"));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Delete the temporary KDE home directory.
     base::DeleteFile(user_home_, true);
     PlatformTest::TearDown();
diff --git a/net/proxy/proxy_config_service_mac.h b/net/proxy/proxy_config_service_mac.h
index 6c11c6f..6c60daf 100644
--- a/net/proxy/proxy_config_service_mac.h
+++ b/net/proxy/proxy_config_service_mac.h
@@ -31,9 +31,9 @@
 
  public:
   // ProxyConfigService implementation:
-  virtual void AddObserver(Observer* observer) OVERRIDE;
-  virtual void RemoveObserver(Observer* observer) OVERRIDE;
-  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) OVERRIDE;
+  virtual void AddObserver(Observer* observer) override;
+  virtual void RemoveObserver(Observer* observer) override;
+  virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) override;
 
  private:
   class Helper;
@@ -46,10 +46,10 @@
         : proxy_config_service_(proxy_config_service) {}
 
     // NetworkConfigWatcherMac::Delegate implementation:
-    virtual void StartReachabilityNotifications() OVERRIDE {}
+    virtual void StartReachabilityNotifications() override {}
     virtual void SetDynamicStoreNotificationKeys(
-        SCDynamicStoreRef store) OVERRIDE;
-    virtual void OnNetworkConfigChange(CFArrayRef changed_keys) OVERRIDE;
+        SCDynamicStoreRef store) override;
+    virtual void OnNetworkConfigChange(CFArrayRef changed_keys) override;
 
    private:
     ProxyConfigServiceMac* const proxy_config_service_;
diff --git a/net/proxy/proxy_config_service_win.h b/net/proxy/proxy_config_service_win.h
index aa91b68..62f1f12 100644
--- a/net/proxy/proxy_config_service_win.h
+++ b/net/proxy/proxy_config_service_win.h
@@ -47,7 +47,7 @@
   virtual ~ProxyConfigServiceWin();
 
   // Overrides a function from PollingProxyConfigService.
-  virtual void AddObserver(Observer* observer) OVERRIDE;
+  virtual void AddObserver(Observer* observer) override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ProxyConfigServiceWinTest, SetFromIEConfig);
@@ -63,7 +63,7 @@
 
   // ObjectWatcher::Delegate methods:
   // This is called whenever one of the registry keys we are watching change.
-  virtual void OnObjectSignaled(HANDLE object) OVERRIDE;
+  virtual void OnObjectSignaled(HANDLE object) override;
 
   static void GetCurrentProxyConfig(ProxyConfig* config);
 
diff --git a/net/proxy/proxy_resolver_mac.h b/net/proxy/proxy_resolver_mac.h
index 24eb10d..c732988 100644
--- a/net/proxy/proxy_resolver_mac.h
+++ b/net/proxy/proxy_resolver_mac.h
@@ -25,17 +25,17 @@
                              ProxyInfo* results,
                              const net::CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE;
+                             const BoundNetLog& net_log) override;
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE;
+  virtual void CancelRequest(RequestHandle request) override;
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE;
+  virtual LoadState GetLoadState(RequestHandle request) const override;
 
-  virtual void CancelSetPacScript() OVERRIDE;
+  virtual void CancelSetPacScript() override;
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const net::CompletionCallback& /*callback*/) OVERRIDE;
+      const net::CompletionCallback& /*callback*/) override;
 
  private:
   scoped_refptr<ProxyResolverScriptData> script_data_;
diff --git a/net/proxy/proxy_resolver_perftest.cc b/net/proxy/proxy_resolver_perftest.cc
index 3d7854c..061c13e 100644
--- a/net/proxy/proxy_resolver_perftest.cc
+++ b/net/proxy/proxy_resolver_perftest.cc
@@ -199,20 +199,20 @@
  public:
   MockJSBindings() {}
 
-  virtual void Alert(const base::string16& message) OVERRIDE {
+  virtual void Alert(const base::string16& message) override {
     CHECK(false);
   }
 
   virtual bool ResolveDns(const std::string& host,
                           ResolveDnsOperation op,
                           std::string* output,
-                          bool* terminate) OVERRIDE {
+                          bool* terminate) override {
     CHECK(false);
     return false;
   }
 
   virtual void OnError(int line_number,
-                       const base::string16& message) OVERRIDE {
+                       const base::string16& message) override {
     CHECK(false);
   }
 };
diff --git a/net/proxy/proxy_resolver_v8.cc b/net/proxy/proxy_resolver_v8.cc
index 37f31bf..dc224cd 100644
--- a/net/proxy/proxy_resolver_v8.cc
+++ b/net/proxy/proxy_resolver_v8.cc
@@ -93,11 +93,11 @@
       const scoped_refptr<ProxyResolverScriptData>& script_data)
       : script_data_(script_data) {}
 
-  virtual const uint16_t* data() const OVERRIDE {
+  virtual const uint16_t* data() const override {
     return reinterpret_cast<const uint16*>(script_data_->utf16().data());
   }
 
-  virtual size_t length() const OVERRIDE {
+  virtual size_t length() const override {
     return script_data_->utf16().size();
   }
 
@@ -107,7 +107,8 @@
 };
 
 // External string wrapper so V8 can access a string literal.
-class V8ExternalASCIILiteral : public v8::String::ExternalAsciiStringResource {
+class V8ExternalASCIILiteral
+    : public v8::String::ExternalOneByteStringResource {
  public:
   // |ascii| must be a NULL-terminated C string, and must remain valid
   // throughout this object's lifetime.
@@ -116,11 +117,11 @@
     DCHECK(base::IsStringASCII(ascii));
   }
 
-  virtual const char* data() const OVERRIDE {
+  virtual const char* data() const override {
     return ascii_;
   }
 
-  virtual size_t length() const OVERRIDE {
+  virtual size_t length() const override {
     return length_;
   }
 
diff --git a/net/proxy/proxy_resolver_v8.h b/net/proxy/proxy_resolver_v8.h
index c754e31..38b958d 100644
--- a/net/proxy/proxy_resolver_v8.h
+++ b/net/proxy/proxy_resolver_v8.h
@@ -86,13 +86,13 @@
                              ProxyInfo* results,
                              const net::CompletionCallback& /*callback*/,
                              RequestHandle* /*request*/,
-                             const BoundNetLog& net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle request) OVERRIDE;
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE;
-  virtual void CancelSetPacScript() OVERRIDE;
+                             const BoundNetLog& net_log) override;
+  virtual void CancelRequest(RequestHandle request) override;
+  virtual LoadState GetLoadState(RequestHandle request) const override;
+  virtual void CancelSetPacScript() override;
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const net::CompletionCallback& /*callback*/) OVERRIDE;
+      const net::CompletionCallback& /*callback*/) override;
 
   // Create an isolate to use for the proxy resolver. If the embedder invokes
   // this method multiple times, it must be invoked in a thread safe manner,
diff --git a/net/proxy/proxy_resolver_v8_tracing.cc b/net/proxy/proxy_resolver_v8_tracing.cc
index b7cb185..b5e934b 100644
--- a/net/proxy/proxy_resolver_v8_tracing.cc
+++ b/net/proxy/proxy_resolver_v8_tracing.cc
@@ -148,9 +148,9 @@
   virtual bool ResolveDns(const std::string& host,
                           ResolveDnsOperation op,
                           std::string* output,
-                          bool* terminate) OVERRIDE;
-  virtual void Alert(const base::string16& message) OVERRIDE;
-  virtual void OnError(int line_number, const base::string16& error) OVERRIDE;
+                          bool* terminate) override;
+  virtual void Alert(const base::string16& message) override;
+  virtual void OnError(int line_number, const base::string16& error) override;
 
   bool ResolveDnsBlocking(const std::string& host,
                           ResolveDnsOperation op,
diff --git a/net/proxy/proxy_resolver_v8_tracing.h b/net/proxy/proxy_resolver_v8_tracing.h
index d738a09..92eac03 100644
--- a/net/proxy/proxy_resolver_v8_tracing.h
+++ b/net/proxy/proxy_resolver_v8_tracing.h
@@ -49,13 +49,13 @@
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE;
-  virtual void CancelRequest(RequestHandle request) OVERRIDE;
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE;
-  virtual void CancelSetPacScript() OVERRIDE;
+                             const BoundNetLog& net_log) override;
+  virtual void CancelRequest(RequestHandle request) override;
+  virtual LoadState GetLoadState(RequestHandle request) const override;
+  virtual void CancelSetPacScript() override;
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
 
  private:
   class Job;
diff --git a/net/proxy/proxy_resolver_v8_tracing_unittest.cc b/net/proxy/proxy_resolver_v8_tracing_unittest.cc
index b5ea3e8..a6e38cb 100644
--- a/net/proxy/proxy_resolver_v8_tracing_unittest.cc
+++ b/net/proxy/proxy_resolver_v8_tracing_unittest.cc
@@ -31,7 +31,7 @@
 
 class ProxyResolverV8TracingTest : public testing::Test {
  public:
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Drain any pending messages, which may be left over from cancellation.
     // This way they get reliably run as part of the current test, rather than
     // spilling into the next test's execution.
@@ -71,7 +71,7 @@
   MockErrorObserver() : event_(true, false) {}
 
   virtual void OnPACScriptError(int line_number,
-                                const base::string16& error) OVERRIDE {
+                                const base::string16& error) override {
     {
       base::AutoLock l(lock_);
       output += base::StringPrintf("Error: line %d: %s\n", line_number,
@@ -768,7 +768,7 @@
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE {
+                      const BoundNetLog& net_log) override {
     EXPECT_FALSE(callback.is_null());
     EXPECT_TRUE(out_req);
 
@@ -791,12 +791,12 @@
 
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE {
+                               const BoundNetLog& net_log) override {
     NOTREACHED();
     return ERR_DNS_CACHE_MISS;
   }
 
-  virtual void CancelRequest(RequestHandle req) OVERRIDE {
+  virtual void CancelRequest(RequestHandle req) override {
     EXPECT_EQ(reinterpret_cast<RequestHandle*>(1), req);
     num_cancelled_requests_++;
   }
diff --git a/net/proxy/proxy_resolver_v8_unittest.cc b/net/proxy/proxy_resolver_v8_unittest.cc
index b0f2d17..d0d01d9 100644
--- a/net/proxy/proxy_resolver_v8_unittest.cc
+++ b/net/proxy/proxy_resolver_v8_unittest.cc
@@ -26,7 +26,7 @@
   MockJSBindings() : my_ip_address_count(0), my_ip_address_ex_count(0),
                      should_terminate(false) {}
 
-  virtual void Alert(const base::string16& message) OVERRIDE {
+  virtual void Alert(const base::string16& message) override {
     VLOG(1) << "PAC-alert: " << message;  // Helpful when debugging.
     alerts.push_back(base::UTF16ToUTF8(message));
   }
@@ -34,7 +34,7 @@
   virtual bool ResolveDns(const std::string& host,
                           ResolveDnsOperation op,
                           std::string* output,
-                          bool* terminate) OVERRIDE {
+                          bool* terminate) override {
     *terminate = should_terminate;
 
     if (op == MY_IP_ADDRESS) {
@@ -66,7 +66,7 @@
   }
 
   virtual void OnError(int line_number,
-                       const base::string16& message) OVERRIDE {
+                       const base::string16& message) override {
     // Helpful when debugging.
     VLOG(1) << "PAC-error: [" << line_number << "] " << message;
 
diff --git a/net/proxy/proxy_resolver_winhttp.h b/net/proxy/proxy_resolver_winhttp.h
index 62b5643..caa7a9f 100644
--- a/net/proxy/proxy_resolver_winhttp.h
+++ b/net/proxy/proxy_resolver_winhttp.h
@@ -25,16 +25,16 @@
                              ProxyInfo* results,
                              const net::CompletionCallback& /*callback*/,
                              RequestHandle* /*request*/,
-                             const BoundNetLog& /*net_log*/) OVERRIDE;
-  virtual void CancelRequest(RequestHandle request) OVERRIDE;
+                             const BoundNetLog& /*net_log*/) override;
+  virtual void CancelRequest(RequestHandle request) override;
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE;
+  virtual LoadState GetLoadState(RequestHandle request) const override;
 
-  virtual void CancelSetPacScript() OVERRIDE;
+  virtual void CancelSetPacScript() override;
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& script_data,
-      const net::CompletionCallback& /*callback*/) OVERRIDE;
+      const net::CompletionCallback& /*callback*/) override;
 
  private:
   bool OpenWinHttpSession();
diff --git a/net/proxy/proxy_script_decider_unittest.cc b/net/proxy/proxy_script_decider_unittest.cc
index c50b31e..880a187 100644
--- a/net/proxy/proxy_script_decider_unittest.cc
+++ b/net/proxy/proxy_script_decider_unittest.cc
@@ -107,7 +107,7 @@
   // ProxyScriptFetcher implementation.
   virtual int Fetch(const GURL& url,
                     base::string16* text,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     const Rules::Rule& rule = rules_->GetRuleByUrl(url);
     int rv = rule.fetch_error;
     EXPECT_NE(ERR_UNEXPECTED, rv);
@@ -116,9 +116,9 @@
     return rv;
   }
 
-  virtual void Cancel() OVERRIDE {}
+  virtual void Cancel() override {}
 
-  virtual URLRequestContext* GetRequestContext() const OVERRIDE {
+  virtual URLRequestContext* GetRequestContext() const override {
     return request_context_;
   }
 
@@ -134,9 +134,9 @@
   virtual ~MockDhcpProxyScriptFetcher();
 
   virtual int Fetch(base::string16* utf16_text,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
-  virtual const GURL& GetPacURL() const OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual void Cancel() override;
+  virtual const GURL& GetPacURL() const override;
 
   virtual void SetPacURL(const GURL& url);
 
@@ -310,7 +310,7 @@
       : rule_(rules_.AddSuccessRule("http://wpad/wpad.dat")),
         fetcher_(&rules_) { }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     request_context_.set_host_resolver(&resolver_);
     fetcher_.SetRequestContext(&request_context_);
     config_.set_auto_detect(true);
@@ -643,15 +643,15 @@
   }
 
   virtual int Fetch(base::string16* utf16_text,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     *utf16_text = expected_text_;
     return OK;
   }
 
-  virtual void Cancel() OVERRIDE {
+  virtual void Cancel() override {
   }
 
-  virtual const GURL& GetPacURL() const OVERRIDE {
+  virtual const GURL& GetPacURL() const override {
     return gurl_;
   }
 
@@ -725,7 +725,7 @@
   virtual ~AsyncFailDhcpFetcher() {}
 
   virtual int Fetch(base::string16* utf16_text,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     callback_ = callback;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
@@ -733,11 +733,11 @@
     return ERR_IO_PENDING;
   }
 
-  virtual void Cancel() OVERRIDE {
+  virtual void Cancel() override {
     callback_.Reset();
   }
 
-  virtual const GURL& GetPacURL() const OVERRIDE {
+  virtual const GURL& GetPacURL() const override {
     return dummy_gurl_;
   }
 
diff --git a/net/proxy/proxy_script_fetcher_impl.h b/net/proxy/proxy_script_fetcher_impl.h
index 31e60b4..8cdcf81 100644
--- a/net/proxy/proxy_script_fetcher_impl.h
+++ b/net/proxy/proxy_script_fetcher_impl.h
@@ -46,18 +46,18 @@
 
   // ProxyScriptFetcher methods:
   virtual int Fetch(const GURL& url, base::string16* text,
-                    const net::CompletionCallback& callback) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
-  virtual URLRequestContext* GetRequestContext() const OVERRIDE;
+                    const net::CompletionCallback& callback) override;
+  virtual void Cancel() override;
+  virtual URLRequestContext* GetRequestContext() const override;
 
   // URLRequest::Delegate methods:
   virtual void OnAuthRequired(URLRequest* request,
-                              AuthChallengeInfo* auth_info) OVERRIDE;
+                              AuthChallengeInfo* auth_info) override;
   virtual void OnSSLCertificateError(URLRequest* request,
                                      const SSLInfo& ssl_info,
-                                     bool is_hsts_ok) OVERRIDE;
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
-  virtual void OnReadCompleted(URLRequest* request, int num_bytes) OVERRIDE;
+                                     bool is_hsts_ok) override;
+  virtual void OnResponseStarted(URLRequest* request) override;
+  virtual void OnReadCompleted(URLRequest* request, int num_bytes) override;
 
  private:
   enum { kBufSize = 4096 };
diff --git a/net/proxy/proxy_script_fetcher_impl_unittest.cc b/net/proxy/proxy_script_fetcher_impl_unittest.cc
index bc927e0..5eb887e 100644
--- a/net/proxy/proxy_script_fetcher_impl_unittest.cc
+++ b/net/proxy/proxy_script_fetcher_impl_unittest.cc
@@ -117,74 +117,74 @@
  private:
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE {
+                                 GURL* new_url) override {
     EXPECT_TRUE(request->load_flags() & LOAD_DISABLE_CERT_REVOCATION_CHECKING);
     return OK;
   }
 
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
-                                  HttpRequestHeaders* headers) OVERRIDE {
+                                  HttpRequestHeaders* headers) override {
     return OK;
   }
 
   virtual void OnSendHeaders(URLRequest* request,
-                             const HttpRequestHeaders& headers) OVERRIDE {}
+                             const HttpRequestHeaders& headers) override {}
 
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE {
+      GURL* allowed_unsafe_redirect_url) override {
     return OK;
   }
 
   virtual void OnBeforeRedirect(URLRequest* request,
-                                const GURL& new_location) OVERRIDE {}
+                                const GURL& new_location) override {}
 
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {}
+  virtual void OnResponseStarted(URLRequest* request) override {}
 
   virtual void OnRawBytesRead(const URLRequest& request,
-                              int bytes_read) OVERRIDE {}
+                              int bytes_read) override {}
 
-  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE {}
+  virtual void OnCompleted(URLRequest* request, bool started) override {}
 
-  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE {}
+  virtual void OnURLRequestDestroyed(URLRequest* request) override {}
 
   virtual void OnPACScriptError(int line_number,
-                                const base::string16& error) OVERRIDE {}
+                                const base::string16& error) override {}
 
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE {
+      AuthCredentials* credentials) override {
     return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
   }
 
   virtual bool OnCanGetCookies(const URLRequest& request,
-                               const CookieList& cookie_list) OVERRIDE {
+                               const CookieList& cookie_list) override {
     return true;
   }
 
   virtual bool OnCanSetCookie(const URLRequest& request,
                               const std::string& cookie_line,
-                              CookieOptions* options) OVERRIDE {
+                              CookieOptions* options) override {
     return true;
   }
 
   virtual bool OnCanAccessFile(const net::URLRequest& request,
-                               const base::FilePath& path) const OVERRIDE {
+                               const base::FilePath& path) const override {
     return true;
   }
-  virtual bool OnCanThrottleRequest(const URLRequest& request) const OVERRIDE {
+  virtual bool OnCanThrottleRequest(const URLRequest& request) const override {
     return false;
   }
 
   virtual int OnBeforeSocketStreamConnect(
       SocketStream* stream,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     return OK;
   }
 
diff --git a/net/proxy/proxy_service.cc b/net/proxy/proxy_service.cc
index 47a4dc2..52e9f7f 100644
--- a/net/proxy/proxy_service.cc
+++ b/net/proxy/proxy_service.cc
@@ -121,7 +121,7 @@
 
   virtual Mode GetNextDelay(int initial_error,
                             TimeDelta current_delay,
-                            TimeDelta* next_delay) const OVERRIDE {
+                            TimeDelta* next_delay) const override {
     if (initial_error != OK) {
       // Re-try policy for failures.
       const int kDelay1Seconds = 8;
@@ -160,10 +160,10 @@
 class ProxyConfigServiceDirect : public ProxyConfigService {
  public:
   // ProxyConfigService implementation:
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
+  virtual void AddObserver(Observer* observer) override {}
+  virtual void RemoveObserver(Observer* observer) override {}
   virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config)
-      OVERRIDE {
+      override {
     *config = ProxyConfig::CreateDirect();
     config->set_source(PROXY_CONFIG_SOURCE_UNKNOWN);
     return CONFIG_VALID;
@@ -180,26 +180,26 @@
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     return ERR_NOT_IMPLEMENTED;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
+  virtual void CancelRequest(RequestHandle request) override {
     NOTREACHED();
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
+  virtual LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
+  virtual void CancelSetPacScript() override {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& /*script_data*/,
-      const CompletionCallback& /*callback*/) OVERRIDE {
+      const CompletionCallback& /*callback*/) override {
     return ERR_NOT_IMPLEMENTED;
   }
 };
@@ -216,27 +216,27 @@
                              ProxyInfo* results,
                              const CompletionCallback& callback,
                              RequestHandle* request,
-                             const BoundNetLog& net_log) OVERRIDE {
+                             const BoundNetLog& net_log) override {
     results->UsePacString(pac_string_);
     return OK;
   }
 
-  virtual void CancelRequest(RequestHandle request) OVERRIDE {
+  virtual void CancelRequest(RequestHandle request) override {
     NOTREACHED();
   }
 
-  virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
+  virtual LoadState GetLoadState(RequestHandle request) const override {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
-  virtual void CancelSetPacScript() OVERRIDE {
+  virtual void CancelSetPacScript() override {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& pac_script,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     return OK;
   }
 
@@ -250,7 +250,7 @@
   ProxyResolverFactoryForSystem()
       : ProxyResolverFactory(false /*expects_pac_bytes*/) {}
 
-  virtual ProxyResolver* CreateProxyResolver() OVERRIDE {
+  virtual ProxyResolver* CreateProxyResolver() override {
     DCHECK(IsSupported());
 #if defined(OS_WIN)
     return new ProxyResolverWinHttp();
@@ -313,10 +313,10 @@
   UnsetProxyConfigService() {}
   virtual ~UnsetProxyConfigService() {}
 
-  virtual void AddObserver(Observer* observer) OVERRIDE {}
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {}
+  virtual void AddObserver(Observer* observer) override {}
+  virtual void RemoveObserver(Observer* observer) override {}
   virtual ConfigAvailability GetLatestProxyConfig(
-      ProxyConfig* config) OVERRIDE {
+      ProxyConfig* config) override {
     return CONFIG_UNSET;
   }
 };
diff --git a/net/proxy/proxy_service.h b/net/proxy/proxy_service.h
index 9fdcb58..6f32c29 100644
--- a/net/proxy/proxy_service.h
+++ b/net/proxy/proxy_service.h
@@ -356,16 +356,16 @@
 
   // NetworkChangeNotifier::IPAddressObserver
   // When this is called, we re-fetch PAC scripts and re-run WPAD.
-  virtual void OnIPAddressChanged() OVERRIDE;
+  virtual void OnIPAddressChanged() override;
 
   // NetworkChangeNotifier::DNSObserver
   // We respond as above.
-  virtual void OnDNSChanged() OVERRIDE;
+  virtual void OnDNSChanged() override;
 
   // ProxyConfigService::Observer
   virtual void OnProxyConfigChanged(
       const ProxyConfig& config,
-      ProxyConfigService::ConfigAvailability availability) OVERRIDE;
+      ProxyConfigService::ConfigAvailability availability) override;
 
   scoped_ptr<ProxyConfigService> config_service_;
   scoped_ptr<ProxyResolver> resolver_;
diff --git a/net/proxy/proxy_service_unittest.cc b/net/proxy/proxy_service_unittest.cc
index a222710..12f9af2 100644
--- a/net/proxy/proxy_service_unittest.cc
+++ b/net/proxy/proxy_service_unittest.cc
@@ -38,7 +38,7 @@
   ImmediatePollPolicy() {}
 
   virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
-                            base::TimeDelta* next_delay) const OVERRIDE {
+                            base::TimeDelta* next_delay) const override {
     *next_delay = base::TimeDelta::FromMilliseconds(1);
     return MODE_USE_TIMER;
   }
@@ -54,7 +54,7 @@
   NeverPollPolicy() {}
 
   virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
-                            base::TimeDelta* next_delay) const OVERRIDE {
+                            base::TimeDelta* next_delay) const override {
     *next_delay = base::TimeDelta::FromDays(60);
     return MODE_USE_TIMER;
   }
@@ -69,7 +69,7 @@
   ImmediateAfterActivityPollPolicy() {}
 
   virtual Mode GetNextDelay(int error, base::TimeDelta current_delay,
-                            base::TimeDelta* next_delay) const OVERRIDE {
+                            base::TimeDelta* next_delay) const override {
     *next_delay = base::TimeDelta();
     return MODE_START_AFTER_ACTIVITY;
   }
@@ -95,13 +95,13 @@
 // are careful to avoid timing problems.
 class ProxyServiceTest : public testing::Test {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     testing::Test::SetUp();
     previous_policy_ =
         ProxyService::set_pac_script_poll_policy(&never_poll_policy_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // Restore the original policy.
     ProxyService::set_pac_script_poll_policy(previous_policy_);
     testing::Test::TearDown();
@@ -127,16 +127,16 @@
         config_(ProxyConfig::CreateFromCustomPacURL(GURL(pac_url))) {
   }
 
-  virtual void AddObserver(Observer* observer) OVERRIDE {
+  virtual void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
   virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* results)
-      OVERRIDE {
+      override {
     if (availability_ == CONFIG_VALID)
       *results = config_;
     return availability_;
@@ -168,7 +168,7 @@
   virtual void OnResolveProxy(const GURL& url,
                               int load_flags,
                               const ProxyService& proxy_service,
-                              ProxyInfo* result) OVERRIDE {
+                              ProxyInfo* result) override {
     on_resolve_proxy_called_ = true;
     proxy_service_ = &proxy_service;
     DCHECK(!add_proxy_ || !remove_proxy_);
@@ -211,7 +211,7 @@
   }
 
   virtual void OnProxyFallback(const ProxyServer& proxy_server,
-                               int net_error) OVERRIDE {
+                               int net_error) override {
     proxy_server_ = proxy_server;
     proxy_fallback_net_error_ = net_error;
     on_proxy_fallback_called_ = true;
diff --git a/net/quic/congestion_control/cubic.cc b/net/quic/congestion_control/cubic.cc
index dec529d..22b0a90 100644
--- a/net/quic/congestion_control/cubic.cc
+++ b/net/quic/congestion_control/cubic.cc
@@ -82,8 +82,8 @@
     QuicTcpCongestionWindow new_cubic_mode_cwnd,
     QuicTcpCongestionWindow new_reno_mode_cwnd) {
 
-  QuicTcpCongestionWindow highest_new_cwnd = std::max(new_cubic_mode_cwnd,
-                                                      new_reno_mode_cwnd);
+  QuicTcpCongestionWindow highest_new_cwnd = max(new_cubic_mode_cwnd,
+                                                 new_reno_mode_cwnd);
   if (last_congestion_window_ < highest_new_cwnd) {
     // cwnd will increase to highest_new_cwnd.
     stats_->cwnd_increase_congestion_avoidance +=
diff --git a/net/quic/congestion_control/hybrid_slow_start.cc b/net/quic/congestion_control/hybrid_slow_start.cc
index 2ae3b50..4b1e842 100644
--- a/net/quic/congestion_control/hybrid_slow_start.cc
+++ b/net/quic/congestion_control/hybrid_slow_start.cc
@@ -18,8 +18,8 @@
 const uint32 kHybridStartMinSamples = 8;
 const int kHybridStartDelayFactorExp = 4;  // 2^4 = 16
 // The original paper specifies 2 and 8ms, but those have changed over time.
-const int kHybridStartDelayMinThresholdUs = 4000;
-const int kHybridStartDelayMaxThresholdUs = 16000;
+const int64 kHybridStartDelayMinThresholdUs = 4000;
+const int64 kHybridStartDelayMaxThresholdUs = 16000;
 
 HybridSlowStart::HybridSlowStart(const QuicClock* clock)
     : clock_(clock),
@@ -116,7 +116,7 @@
   // We only need to check this once per round.
   if (rtt_sample_count_ == kHybridStartMinSamples) {
     // Divide min_rtt by 16 to get a rtt increase threshold for exiting.
-    int min_rtt_increase_threshold_us = min_rtt.ToMicroseconds() >>
+    int64 min_rtt_increase_threshold_us = min_rtt.ToMicroseconds() >>
         kHybridStartDelayFactorExp;
     // Ensure the rtt threshold is never less than 2ms or more than 16ms.
     min_rtt_increase_threshold_us = min(min_rtt_increase_threshold_us,
diff --git a/net/quic/congestion_control/pacing_sender.cc b/net/quic/congestion_control/pacing_sender.cc
index 20d2b3b..03e5534 100644
--- a/net/quic/congestion_control/pacing_sender.cc
+++ b/net/quic/congestion_control/pacing_sender.cc
@@ -15,15 +15,12 @@
       burst_tokens_(initial_packet_burst),
       last_delayed_packet_sent_time_(QuicTime::Zero()),
       next_packet_send_time_(QuicTime::Zero()),
-      was_last_send_delayed_(false),
-      has_valid_rtt_(false) {
+      was_last_send_delayed_(false) {
 }
 
 PacingSender::~PacingSender() {}
 
 void PacingSender::SetFromConfig(const QuicConfig& config, bool is_server) {
-  // TODO(ianswett): Consider using the suggested RTT for pacing an initial
-  // response.
   sender_->SetFromConfig(config, is_server);
 }
 
@@ -42,9 +39,6 @@
                                      QuicByteCount bytes_in_flight,
                                      const CongestionVector& acked_packets,
                                      const CongestionVector& lost_packets) {
-  if (rtt_updated) {
-    has_valid_rtt_ = true;
-  }
   sender_->OnCongestionEvent(
       rtt_updated, bytes_in_flight, acked_packets, lost_packets);
 }
@@ -55,11 +49,10 @@
     QuicPacketSequenceNumber sequence_number,
     QuicByteCount bytes,
     HasRetransmittableData has_retransmittable_data) {
-  // Only pace data packets once we have an updated RTT.
   const bool in_flight =
       sender_->OnPacketSent(sent_time, bytes_in_flight, sequence_number,
                             bytes, has_retransmittable_data);
-  if (has_retransmittable_data != HAS_RETRANSMITTABLE_DATA || !has_valid_rtt_) {
+  if (has_retransmittable_data != HAS_RETRANSMITTABLE_DATA) {
     return in_flight;
   }
   if (burst_tokens_ > 0) {
@@ -117,10 +110,6 @@
       HasRetransmittableData has_retransmittable_data) const {
   QuicTime::Delta time_until_send =
       sender_->TimeUntilSend(now, bytes_in_flight, has_retransmittable_data);
-  if (!has_valid_rtt_) {
-    // Don't pace if we don't have an updated RTT estimate.
-    return time_until_send;
-  }
   if (bytes_in_flight == 0) {
     // Add more burst tokens anytime the connection is entering quiescence.
     burst_tokens_ = initial_packet_burst_;
@@ -143,6 +132,8 @@
   }
 
   // If the next send time is within the alarm granularity, send immediately.
+  // TODO(ianswett): This granularity logic ends up sending more packets than
+  // intended in an effort to make up for lost time that wasn't lost.
   if (next_packet_send_time_ > now.Add(alarm_granularity_)) {
     DVLOG(1) << "Delaying packet: "
              << next_packet_send_time_.Subtract(now).ToMicroseconds();
diff --git a/net/quic/congestion_control/pacing_sender.h b/net/quic/congestion_control/pacing_sender.h
index f61ae75..e50527d 100644
--- a/net/quic/congestion_control/pacing_sender.h
+++ b/net/quic/congestion_control/pacing_sender.h
@@ -35,34 +35,34 @@
   virtual ~PacingSender();
 
   // SendAlgorithmInterface methods.
-  virtual void SetFromConfig(const QuicConfig& config, bool is_server) OVERRIDE;
-  virtual void SetNumEmulatedConnections(int num_connections) OVERRIDE;
+  virtual void SetFromConfig(const QuicConfig& config, bool is_server) override;
+  virtual void SetNumEmulatedConnections(int num_connections) override;
   virtual void OnIncomingQuicCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& feedback,
-      QuicTime feedback_receive_time) OVERRIDE;
+      QuicTime feedback_receive_time) override;
   virtual void OnCongestionEvent(bool rtt_updated,
                                  QuicByteCount bytes_in_flight,
                                  const CongestionVector& acked_packets,
-                                 const CongestionVector& lost_packets) OVERRIDE;
+                                 const CongestionVector& lost_packets) override;
   virtual bool OnPacketSent(QuicTime sent_time,
                             QuicByteCount bytes_in_flight,
                             QuicPacketSequenceNumber sequence_number,
                             QuicByteCount bytes,
-                            HasRetransmittableData is_retransmittable) OVERRIDE;
-  virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
-  virtual void RevertRetransmissionTimeout() OVERRIDE;
+                            HasRetransmittableData is_retransmittable) override;
+  virtual void OnRetransmissionTimeout(bool packets_retransmitted) override;
+  virtual void RevertRetransmissionTimeout() override;
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
       QuicByteCount bytes_in_flight,
-      HasRetransmittableData has_retransmittable_data) const OVERRIDE;
-  virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
-  virtual bool HasReliableBandwidthEstimate() const OVERRIDE;
-  virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
-  virtual QuicByteCount GetCongestionWindow() const OVERRIDE;
-  virtual bool InSlowStart() const OVERRIDE;
-  virtual bool InRecovery() const OVERRIDE;
-  virtual QuicByteCount GetSlowStartThreshold() const OVERRIDE;
-  virtual CongestionControlType GetCongestionControlType() const OVERRIDE;
+      HasRetransmittableData has_retransmittable_data) const override;
+  virtual QuicBandwidth BandwidthEstimate() const override;
+  virtual bool HasReliableBandwidthEstimate() const override;
+  virtual QuicTime::Delta RetransmissionDelay() const override;
+  virtual QuicByteCount GetCongestionWindow() const override;
+  virtual bool InSlowStart() const override;
+  virtual bool InRecovery() const override;
+  virtual QuicByteCount GetSlowStartThreshold() const override;
+  virtual CongestionControlType GetCongestionControlType() const override;
 
  private:
   scoped_ptr<SendAlgorithmInterface> sender_;  // Underlying sender.
@@ -73,7 +73,6 @@
   QuicTime last_delayed_packet_sent_time_;
   QuicTime next_packet_send_time_;  // When can the next packet be sent.
   mutable bool was_last_send_delayed_;  // True when the last send was delayed.
-  bool has_valid_rtt_;  // True if we have at least one RTT update.
 
   DISALLOW_COPY_AND_ASSIGN(PacingSender);
 };
diff --git a/net/quic/congestion_control/pacing_sender_test.cc b/net/quic/congestion_control/pacing_sender_test.cc
index 768cc22..f887c54 100644
--- a/net/quic/congestion_control/pacing_sender_test.cc
+++ b/net/quic/congestion_control/pacing_sender_test.cc
@@ -19,6 +19,7 @@
 namespace test {
 
 const QuicByteCount kBytesInFlight = 1024;
+const int kInitialBurstPackets = 10;
 
 class PacingSenderTest : public ::testing::Test {
  protected:
@@ -142,11 +143,6 @@
       .WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta(
           kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2))));
 
-  // Send a whole pile of packets, and verify that they are not paced.
-  for (int i = 0 ; i < 1000; ++i) {
-    CheckPacketIsSentImmediately();
-  }
-
   // Now update the RTT and verify that packets are actually paced.
   EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _));
   SendAlgorithmInterface::CongestionVector empty_map;
@@ -217,11 +213,6 @@
       .WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta(
           kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2))));
 
-  // Send a whole pile of packets, and verify that they are not paced.
-  for (int i = 0 ; i < 1000; ++i) {
-    CheckPacketIsSentImmediately();
-  }
-
   // Now update the RTT and verify that packets are actually paced.
   EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _));
   SendAlgorithmInterface::CongestionVector empty_map;
@@ -296,17 +287,17 @@
   pacing_sender_->OnCongestionEvent(true, kBytesInFlight, empty_map, empty_map);
 
   // Send 10 packets, and verify that they are not paced.
-  for (int i = 0 ; i < 10; ++i) {
+  for (int i = 0 ; i < kInitialBurstPackets; ++i) {
     CheckPacketIsSentImmediately();
   }
 
-  CheckPacketIsSentImmediately();
-  CheckPacketIsSentImmediately();
-  CheckPacketIsSentImmediately();
-
   // The first packet was a "make up", then we sent two packets "into the
-  // future", so the delay should be 2.
+  // future", so the delay should be 2ms.
+  CheckPacketIsSentImmediately();
+  CheckPacketIsSentImmediately();
+  CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
+
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
   CheckPacketIsSentImmediately();
 
@@ -321,14 +312,70 @@
             pacing_sender_->TimeUntilSend(clock_.Now(),
                                           0,
                                           HAS_RETRANSMITTABLE_DATA));
-  for (int i = 0 ; i < 10; ++i) {
+  for (int i = 0 ; i < kInitialBurstPackets; ++i) {
     CheckPacketIsSentImmediately();
   }
 
+  // The first packet was a "make up", then we sent two packets "into the
+  // future", so the delay should be 2ms.
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
+  CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
+}
+
+TEST_F(PacingSenderTest, InitialBurstNoRttMeasurement) {
+  pacing_sender_.reset();
+  mock_sender_ = new StrictMock<MockSendAlgorithm>();
+  pacing_sender_.reset(new PacingSender(mock_sender_,
+                                        QuicTime::Delta::FromMilliseconds(1),
+                                        10));
+  // Start the test in slow start.
+  EXPECT_CALL(*mock_sender_, InSlowStart()).WillRepeatedly(Return(true));
+
+  // Configure bandwith of 1 packet per 2 ms, for which the pacing rate
+  // will be 1 packet per 1 ms.
+  EXPECT_CALL(*mock_sender_, BandwidthEstimate())
+      .WillRepeatedly(Return(QuicBandwidth::FromBytesAndTimeDelta(
+          kMaxPacketSize, QuicTime::Delta::FromMilliseconds(2))));
+
+  // Send 10 packets, and verify that they are not paced.
+  for (int i = 0 ; i < kInitialBurstPackets; ++i) {
+    CheckPacketIsSentImmediately();
+  }
+
+  // The first packet was a "make up", then we sent two packets "into the
+  // future", so the delay should be 2ms.
+  CheckPacketIsSentImmediately();
+  CheckPacketIsSentImmediately();
+  CheckPacketIsSentImmediately();
+  CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
+
+
+  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
+  CheckPacketIsSentImmediately();
 
+  // Next time TimeUntilSend is called with no bytes in flight, the tokens
+  // should be refilled and there should be no delay.
+  EXPECT_CALL(*mock_sender_,
+              TimeUntilSend(clock_.Now(),
+                            0,
+                            HAS_RETRANSMITTABLE_DATA)).
+      WillOnce(Return(zero_time_));
+  EXPECT_EQ(zero_time_,
+            pacing_sender_->TimeUntilSend(clock_.Now(),
+                                          0,
+                                          HAS_RETRANSMITTABLE_DATA));
+  // Send 10 packets, and verify that they are not paced.
+  for (int i = 0 ; i < kInitialBurstPackets; ++i) {
+    CheckPacketIsSentImmediately();
+  }
+
+  // The first packet was a "make up", then we sent two packets "into the
+  // future", so the delay should be 2ms.
+  CheckPacketIsSentImmediately();
+  CheckPacketIsSentImmediately();
+  CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 }
 
diff --git a/net/quic/congestion_control/tcp_cubic_sender.h b/net/quic/congestion_control/tcp_cubic_sender.h
index 8851ac4..dd0df58 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.h
+++ b/net/quic/congestion_control/tcp_cubic_sender.h
@@ -38,34 +38,34 @@
   virtual ~TcpCubicSender();
 
   // Start implementation of SendAlgorithmInterface.
-  virtual void SetFromConfig(const QuicConfig& config, bool is_server) OVERRIDE;
-  virtual void SetNumEmulatedConnections(int num_connections) OVERRIDE;
+  virtual void SetFromConfig(const QuicConfig& config, bool is_server) override;
+  virtual void SetNumEmulatedConnections(int num_connections) override;
   virtual void OnIncomingQuicCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& feedback,
-      QuicTime feedback_receive_time) OVERRIDE;
+      QuicTime feedback_receive_time) override;
   virtual void OnCongestionEvent(bool rtt_updated,
                                  QuicByteCount bytes_in_flight,
                                  const CongestionVector& acked_packets,
-                                 const CongestionVector& lost_packets) OVERRIDE;
+                                 const CongestionVector& lost_packets) override;
   virtual bool OnPacketSent(QuicTime sent_time,
                             QuicByteCount bytes_in_flight,
                             QuicPacketSequenceNumber sequence_number,
                             QuicByteCount bytes,
-                            HasRetransmittableData is_retransmittable) OVERRIDE;
-  virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
-  virtual void RevertRetransmissionTimeout() OVERRIDE;
+                            HasRetransmittableData is_retransmittable) override;
+  virtual void OnRetransmissionTimeout(bool packets_retransmitted) override;
+  virtual void RevertRetransmissionTimeout() override;
   virtual QuicTime::Delta TimeUntilSend(
       QuicTime now,
       QuicByteCount bytes_in_flight,
-      HasRetransmittableData has_retransmittable_data) const OVERRIDE;
-  virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
-  virtual bool HasReliableBandwidthEstimate() const OVERRIDE;
-  virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
-  virtual QuicByteCount GetCongestionWindow() const OVERRIDE;
-  virtual bool InSlowStart() const OVERRIDE;
-  virtual bool InRecovery() const OVERRIDE;
-  virtual QuicByteCount GetSlowStartThreshold() const OVERRIDE;
-  virtual CongestionControlType GetCongestionControlType() const OVERRIDE;
+      HasRetransmittableData has_retransmittable_data) const override;
+  virtual QuicBandwidth BandwidthEstimate() const override;
+  virtual bool HasReliableBandwidthEstimate() const override;
+  virtual QuicTime::Delta RetransmissionDelay() const override;
+  virtual QuicByteCount GetCongestionWindow() const override;
+  virtual bool InSlowStart() const override;
+  virtual bool InRecovery() const override;
+  virtual QuicByteCount GetSlowStartThreshold() const override;
+  virtual CongestionControlType GetCongestionControlType() const override;
   // End implementation of SendAlgorithmInterface.
 
  private:
diff --git a/net/quic/congestion_control/tcp_cubic_sender_test.cc b/net/quic/congestion_control/tcp_cubic_sender_test.cc
index 851c1a1..731b8f5 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_test.cc
@@ -670,8 +670,8 @@
   expected_send_window /= 2;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 
-  // No congestion window growth should occur in recovery phase, i.e.,
-  // until the currently outstanding 20 packets are acked.
+  // No congestion window growth should occur in recovery phase, i.e., until the
+  // currently outstanding 20 packets are acked.
   for (int i = 0; i < 10; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
diff --git a/net/quic/congestion_control/tcp_loss_algorithm.cc b/net/quic/congestion_control/tcp_loss_algorithm.cc
index 557681e..b0a5a15 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm.cc
+++ b/net/quic/congestion_control/tcp_loss_algorithm.cc
@@ -46,7 +46,9 @@
     }
 
     LOG_IF(DFATAL, it->nack_count == 0)
-        << "All packets less than largest observed should have been nacked.";
+        << "All packets less than largest observed should have been nacked."
+        << "sequence_number:" << sequence_number
+        << " largest_observed:" << largest_observed;
     if (it->nack_count >= kNumberOfNacksBeforeRetransmission) {
       lost_packets.insert(sequence_number);
       continue;
diff --git a/net/quic/congestion_control/tcp_loss_algorithm.h b/net/quic/congestion_control/tcp_loss_algorithm.h
index 5f0bcfb..201354b 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm.h
+++ b/net/quic/congestion_control/tcp_loss_algorithm.h
@@ -23,17 +23,17 @@
   TCPLossAlgorithm();
   virtual ~TCPLossAlgorithm() {}
 
-  virtual LossDetectionType GetLossDetectionType() const OVERRIDE;
+  virtual LossDetectionType GetLossDetectionType() const override;
 
   // Uses nack counts to decide when packets are lost.
   virtual SequenceNumberSet DetectLostPackets(
       const QuicUnackedPacketMap& unacked_packets,
       const QuicTime& time,
       QuicPacketSequenceNumber largest_observed,
-      const RttStats& rtt_stats) OVERRIDE;
+      const RttStats& rtt_stats) override;
 
   // Returns a non-zero value when the early retransmit timer is active.
-  virtual QuicTime GetLossTimeout() const OVERRIDE;
+  virtual QuicTime GetLossTimeout() const override;
 
  private:
   QuicTime loss_detection_timeout_;
diff --git a/net/quic/congestion_control/tcp_receiver.h b/net/quic/congestion_control/tcp_receiver.h
index a5e5b1b..89e9186 100644
--- a/net/quic/congestion_control/tcp_receiver.h
+++ b/net/quic/congestion_control/tcp_receiver.h
@@ -25,11 +25,11 @@
 
   // Start implementation of SendAlgorithmInterface.
   virtual bool GenerateCongestionFeedback(
-      QuicCongestionFeedbackFrame* feedback) OVERRIDE;
+      QuicCongestionFeedbackFrame* feedback) override;
 
   virtual void RecordIncomingPacket(QuicByteCount bytes,
                                     QuicPacketSequenceNumber sequence_number,
-                                    QuicTime timestamp) OVERRIDE;
+                                    QuicTime timestamp) override;
 
  private:
   QuicByteCount receive_window_;
diff --git a/net/quic/congestion_control/time_loss_algorithm.h b/net/quic/congestion_control/time_loss_algorithm.h
index ae37e1e..de517ef 100644
--- a/net/quic/congestion_control/time_loss_algorithm.h
+++ b/net/quic/congestion_control/time_loss_algorithm.h
@@ -23,7 +23,7 @@
   TimeLossAlgorithm();
   virtual ~TimeLossAlgorithm() {}
 
-  virtual LossDetectionType GetLossDetectionType() const OVERRIDE;
+  virtual LossDetectionType GetLossDetectionType() const override;
 
   // Declares pending packets less than the largest observed lost when it has
   // been 1.25 RTT since they were sent.  Packets larger than the largest
@@ -32,14 +32,14 @@
       const QuicUnackedPacketMap& unacked_packets,
       const QuicTime& time,
       QuicPacketSequenceNumber largest_observed,
-      const RttStats& rtt_stats) OVERRIDE;
+      const RttStats& rtt_stats) override;
 
   // Returns the time the next packet will be lost, or zero if there
   // are no nacked pending packets outstanding.
   // TODO(ianswett): Ideally the RTT variance and the RTT would be used to
   // determine the time a packet is considered lost.
   // TODO(ianswett): Consider using Max(1.25 * srtt, 1.125 * last_rtt).
-  virtual QuicTime GetLossTimeout() const OVERRIDE;
+  virtual QuicTime GetLossTimeout() const override;
 
  private:
   QuicTime loss_detection_timeout_;
diff --git a/net/quic/crypto/aead_base_decrypter.h b/net/quic/crypto/aead_base_decrypter.h
index 6257409..116dbe1 100644
--- a/net/quic/crypto/aead_base_decrypter.h
+++ b/net/quic/crypto/aead_base_decrypter.h
@@ -40,18 +40,18 @@
   virtual ~AeadBaseDecrypter();
 
   // QuicDecrypter implementation
-  virtual bool SetKey(base::StringPiece key) OVERRIDE;
-  virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) OVERRIDE;
+  virtual bool SetKey(base::StringPiece key) override;
+  virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) override;
   virtual bool Decrypt(base::StringPiece nonce,
                        base::StringPiece associated_data,
                        base::StringPiece ciphertext,
                        unsigned char* output,
-                       size_t* output_length) OVERRIDE;
+                       size_t* output_length) override;
   virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
                                   base::StringPiece associated_data,
-                                  base::StringPiece ciphertext) OVERRIDE;
-  virtual base::StringPiece GetKey() const OVERRIDE;
-  virtual base::StringPiece GetNoncePrefix() const OVERRIDE;
+                                  base::StringPiece ciphertext) override;
+  virtual base::StringPiece GetKey() const override;
+  virtual base::StringPiece GetNoncePrefix() const override;
 
  protected:
   // Make these constants available to the subclasses so that the subclasses
diff --git a/net/quic/crypto/aead_base_encrypter.h b/net/quic/crypto/aead_base_encrypter.h
index 7138131..89c7a1f 100644
--- a/net/quic/crypto/aead_base_encrypter.h
+++ b/net/quic/crypto/aead_base_encrypter.h
@@ -40,21 +40,21 @@
   virtual ~AeadBaseEncrypter();
 
   // QuicEncrypter implementation
-  virtual bool SetKey(base::StringPiece key) OVERRIDE;
-  virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) OVERRIDE;
+  virtual bool SetKey(base::StringPiece key) override;
+  virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) override;
   virtual bool Encrypt(base::StringPiece nonce,
                        base::StringPiece associated_data,
                        base::StringPiece plaintext,
-                       unsigned char* output) OVERRIDE;
+                       unsigned char* output) override;
   virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
                                   base::StringPiece associated_data,
-                                  base::StringPiece plaintext) OVERRIDE;
-  virtual size_t GetKeySize() const OVERRIDE;
-  virtual size_t GetNoncePrefixSize() const OVERRIDE;
-  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE;
-  virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE;
-  virtual base::StringPiece GetKey() const OVERRIDE;
-  virtual base::StringPiece GetNoncePrefix() const OVERRIDE;
+                                  base::StringPiece plaintext) override;
+  virtual size_t GetKeySize() const override;
+  virtual size_t GetNoncePrefixSize() const override;
+  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override;
+  virtual size_t GetCiphertextSize(size_t plaintext_size) const override;
+  virtual base::StringPiece GetKey() const override;
+  virtual base::StringPiece GetNoncePrefix() const override;
 
  protected:
   // Make these constants available to the subclasses so that the subclasses
diff --git a/net/quic/crypto/aes_128_gcm_12_decrypter.h b/net/quic/crypto/aes_128_gcm_12_decrypter.h
index 0511c8b..4395dc2 100644
--- a/net/quic/crypto/aes_128_gcm_12_decrypter.h
+++ b/net/quic/crypto/aes_128_gcm_12_decrypter.h
@@ -31,7 +31,7 @@
   virtual void FillAeadParams(base::StringPiece nonce,
                               base::StringPiece associated_data,
                               size_t auth_tag_size,
-                              AeadParams* aead_params) const OVERRIDE;
+                              AeadParams* aead_params) const override;
 #endif
 
  private:
diff --git a/net/quic/crypto/aes_128_gcm_12_encrypter.h b/net/quic/crypto/aes_128_gcm_12_encrypter.h
index 1d8f321..afbeb14 100644
--- a/net/quic/crypto/aes_128_gcm_12_encrypter.h
+++ b/net/quic/crypto/aes_128_gcm_12_encrypter.h
@@ -31,7 +31,7 @@
   virtual void FillAeadParams(base::StringPiece nonce,
                               base::StringPiece associated_data,
                               size_t auth_tag_size,
-                              AeadParams* aead_params) const OVERRIDE;
+                              AeadParams* aead_params) const override;
 #endif
 
  private:
diff --git a/net/quic/crypto/chacha20_poly1305_decrypter.h b/net/quic/crypto/chacha20_poly1305_decrypter.h
index 9d24ba2..e3c3e7f 100644
--- a/net/quic/crypto/chacha20_poly1305_decrypter.h
+++ b/net/quic/crypto/chacha20_poly1305_decrypter.h
@@ -35,7 +35,7 @@
   virtual void FillAeadParams(base::StringPiece nonce,
                               base::StringPiece associated_data,
                               size_t auth_tag_size,
-                              AeadParams* aead_params) const OVERRIDE;
+                              AeadParams* aead_params) const override;
 #endif
 
  private:
diff --git a/net/quic/crypto/chacha20_poly1305_encrypter.h b/net/quic/crypto/chacha20_poly1305_encrypter.h
index 4a68caa..b99fa27 100644
--- a/net/quic/crypto/chacha20_poly1305_encrypter.h
+++ b/net/quic/crypto/chacha20_poly1305_encrypter.h
@@ -35,7 +35,7 @@
   virtual void FillAeadParams(base::StringPiece nonce,
                               base::StringPiece associated_data,
                               size_t auth_tag_size,
-                              AeadParams* aead_params) const OVERRIDE;
+                              AeadParams* aead_params) const override;
 #endif
 
  private:
diff --git a/net/quic/crypto/channel_id_chromium.h b/net/quic/crypto/channel_id_chromium.h
index 08cfff9..72f694d 100644
--- a/net/quic/crypto/channel_id_chromium.h
+++ b/net/quic/crypto/channel_id_chromium.h
@@ -24,8 +24,8 @@
 
   // ChannelIDKey interface
   virtual bool Sign(base::StringPiece signed_data,
-                    std::string* out_signature) const OVERRIDE;
-  virtual std::string SerializeKey() const OVERRIDE;
+                    std::string* out_signature) const override;
+  virtual std::string SerializeKey() const override;
 
  private:
   scoped_ptr<crypto::ECPrivateKey> ec_private_key_;
@@ -42,7 +42,7 @@
   virtual QuicAsyncStatus GetChannelIDKey(
       const std::string& hostname,
       scoped_ptr<ChannelIDKey>* channel_id_key,
-      ChannelIDSourceCallback* callback) OVERRIDE;
+      ChannelIDSourceCallback* callback) override;
 
  private:
   class Job;
diff --git a/net/quic/crypto/common_cert_set.cc b/net/quic/crypto/common_cert_set.cc
index f631cd6..0d39ecc 100644
--- a/net/quic/crypto/common_cert_set.cc
+++ b/net/quic/crypto/common_cert_set.cc
@@ -69,12 +69,12 @@
 class CommonCertSetsQUIC : public CommonCertSets {
  public:
   // CommonCertSets interface.
-  virtual StringPiece GetCommonHashes() const OVERRIDE {
+  virtual StringPiece GetCommonHashes() const override {
     return StringPiece(reinterpret_cast<const char*>(kSetHashes),
                        sizeof(uint64) * arraysize(kSetHashes));
   }
 
-  virtual StringPiece GetCert(uint64 hash, uint32 index) const OVERRIDE {
+  virtual StringPiece GetCert(uint64 hash, uint32 index) const override {
     for (size_t i = 0; i < arraysize(kSets); i++) {
       if (kSets[i].hash == hash) {
         if (index < kSets[i].num_certs) {
@@ -90,7 +90,7 @@
   }
 
   virtual bool MatchCert(StringPiece cert, StringPiece common_set_hashes,
-                         uint64* out_hash, uint32* out_index) const OVERRIDE {
+                         uint64* out_hash, uint32* out_index) const override {
     if (common_set_hashes.size() % sizeof(uint64) != 0) {
       return false;
     }
diff --git a/net/quic/crypto/crypto_framer.cc b/net/quic/crypto/crypto_framer.cc
index bc5c8b7..3f61115 100644
--- a/net/quic/crypto/crypto_framer.cc
+++ b/net/quic/crypto/crypto_framer.cc
@@ -26,10 +26,10 @@
  public:
   OneShotVisitor() : error_(false) {}
 
-  virtual void OnError(CryptoFramer* framer) OVERRIDE { error_ = true; }
+  virtual void OnError(CryptoFramer* framer) override { error_ = true; }
 
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE {
+      const CryptoHandshakeMessage& message) override {
     out_.reset(new CryptoHandshakeMessage(message));
   }
 
diff --git a/net/quic/crypto/crypto_framer_test.cc b/net/quic/crypto/crypto_framer_test.cc
index 01e9157..f9ea55d 100644
--- a/net/quic/crypto/crypto_framer_test.cc
+++ b/net/quic/crypto/crypto_framer_test.cc
@@ -33,13 +33,13 @@
  public:
   TestCryptoVisitor() : error_count_(0) {}
 
-  virtual void OnError(CryptoFramer* framer) OVERRIDE {
+  virtual void OnError(CryptoFramer* framer) override {
     DLOG(ERROR) << "CryptoFramer Error: " << framer->error();
     ++error_count_;
   }
 
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE {
+      const CryptoHandshakeMessage& message) override {
     messages_.push_back(message);
   }
 
diff --git a/net/quic/crypto/crypto_server_test.cc b/net/quic/crypto/crypto_server_test.cc
index bb47cbf..1f3380a 100644
--- a/net/quic/crypto/crypto_server_test.cc
+++ b/net/quic/crypto/crypto_server_test.cc
@@ -156,7 +156,7 @@
     }
 
     virtual void RunImpl(const CryptoHandshakeMessage& client_hello,
-                         const Result& result) OVERRIDE {
+                         const Result& result) override {
       {
         // Ensure that the strike register client lock is not held.
         QuicCryptoServerConfigPeer peer(&test_->config_);
diff --git a/net/quic/crypto/curve25519_key_exchange.h b/net/quic/crypto/curve25519_key_exchange.h
index 93288f6..310c614 100644
--- a/net/quic/crypto/curve25519_key_exchange.h
+++ b/net/quic/crypto/curve25519_key_exchange.h
@@ -31,11 +31,11 @@
   static std::string NewPrivateKey(QuicRandom* rand);
 
   // KeyExchange interface.
-  virtual KeyExchange* NewKeyPair(QuicRandom* rand) const OVERRIDE;
+  virtual KeyExchange* NewKeyPair(QuicRandom* rand) const override;
   virtual bool CalculateSharedKey(const base::StringPiece& peer_public_value,
-                                  std::string* shared_key) const OVERRIDE;
-  virtual base::StringPiece public_value() const OVERRIDE;
-  virtual QuicTag tag() const OVERRIDE;
+                                  std::string* shared_key) const override;
+  virtual base::StringPiece public_value() const override;
+  virtual QuicTag tag() const override;
 
  private:
   Curve25519KeyExchange();
diff --git a/net/quic/crypto/local_strike_register_client.h b/net/quic/crypto/local_strike_register_client.h
index fe8ae93..b121299 100644
--- a/net/quic/crypto/local_strike_register_client.h
+++ b/net/quic/crypto/local_strike_register_client.h
@@ -26,10 +26,10 @@
                             const uint8 orbit[8],
                             StrikeRegister::StartupType startup);
 
-  virtual bool IsKnownOrbit(base::StringPiece orbit) const OVERRIDE;
+  virtual bool IsKnownOrbit(base::StringPiece orbit) const override;
   virtual void VerifyNonceIsValidAndUnique(base::StringPiece nonce,
                                            QuicWallTime now,
-                                           ResultCallback* cb) OVERRIDE;
+                                           ResultCallback* cb) override;
 
  private:
   mutable base::Lock m_;
diff --git a/net/quic/crypto/local_strike_register_client_test.cc b/net/quic/crypto/local_strike_register_client_test.cc
index 1a3b6f9..70d2428 100644
--- a/net/quic/crypto/local_strike_register_client_test.cc
+++ b/net/quic/crypto/local_strike_register_client_test.cc
@@ -36,7 +36,7 @@
 
  protected:
   virtual void RunImpl(bool nonce_is_valid_and_unique,
-                       InsertStatus nonce_error) OVERRIDE {
+                       InsertStatus nonce_error) override {
     *called_ = true;
     *saved_value_ = nonce_is_valid_and_unique;
     *saved_nonce_error_ = nonce_error;
diff --git a/net/quic/crypto/null_decrypter.h b/net/quic/crypto/null_decrypter.h
index 2bc2fe8..03038bd 100644
--- a/net/quic/crypto/null_decrypter.h
+++ b/net/quic/crypto/null_decrypter.h
@@ -22,18 +22,18 @@
   virtual ~NullDecrypter() {}
 
   // QuicDecrypter implementation
-  virtual bool SetKey(base::StringPiece key) OVERRIDE;
-  virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) OVERRIDE;
+  virtual bool SetKey(base::StringPiece key) override;
+  virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) override;
   virtual bool Decrypt(base::StringPiece nonce,
                        base::StringPiece associated_data,
                        base::StringPiece ciphertext,
                        unsigned char* output,
-                       size_t* output_length) OVERRIDE;
+                       size_t* output_length) override;
   virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
                                   base::StringPiece associated_data,
-                                  base::StringPiece ciphertext) OVERRIDE;
-  virtual base::StringPiece GetKey() const OVERRIDE;
-  virtual base::StringPiece GetNoncePrefix() const OVERRIDE;
+                                  base::StringPiece ciphertext) override;
+  virtual base::StringPiece GetKey() const override;
+  virtual base::StringPiece GetNoncePrefix() const override;
 
  private:
   bool ReadHash(QuicDataReader* reader, uint128* hash);
diff --git a/net/quic/crypto/null_encrypter.h b/net/quic/crypto/null_encrypter.h
index 1bcdff5..fbd2dff 100644
--- a/net/quic/crypto/null_encrypter.h
+++ b/net/quic/crypto/null_encrypter.h
@@ -20,21 +20,21 @@
   virtual ~NullEncrypter() {}
 
   // QuicEncrypter implementation
-  virtual bool SetKey(base::StringPiece key) OVERRIDE;
-  virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) OVERRIDE;
+  virtual bool SetKey(base::StringPiece key) override;
+  virtual bool SetNoncePrefix(base::StringPiece nonce_prefix) override;
   virtual bool Encrypt(base::StringPiece nonce,
                        base::StringPiece associated_data,
                        base::StringPiece plaintext,
-                       unsigned char* output) OVERRIDE;
+                       unsigned char* output) override;
   virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
                                   base::StringPiece associated_data,
-                                  base::StringPiece plaintext) OVERRIDE;
-  virtual size_t GetKeySize() const OVERRIDE;
-  virtual size_t GetNoncePrefixSize() const OVERRIDE;
-  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE;
-  virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE;
-  virtual base::StringPiece GetKey() const OVERRIDE;
-  virtual base::StringPiece GetNoncePrefix() const OVERRIDE;
+                                  base::StringPiece plaintext) override;
+  virtual size_t GetKeySize() const override;
+  virtual size_t GetNoncePrefixSize() const override;
+  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override;
+  virtual size_t GetCiphertextSize(size_t plaintext_size) const override;
+  virtual base::StringPiece GetKey() const override;
+  virtual base::StringPiece GetNoncePrefix() const override;
 
  private:
   size_t GetHashLength() const;
diff --git a/net/quic/crypto/p256_key_exchange.h b/net/quic/crypto/p256_key_exchange.h
index ce5a0d4..36ba296 100644
--- a/net/quic/crypto/p256_key_exchange.h
+++ b/net/quic/crypto/p256_key_exchange.h
@@ -38,11 +38,11 @@
   static std::string NewPrivateKey();
 
   // KeyExchange interface.
-  virtual KeyExchange* NewKeyPair(QuicRandom* rand) const OVERRIDE;
+  virtual KeyExchange* NewKeyPair(QuicRandom* rand) const override;
   virtual bool CalculateSharedKey(const base::StringPiece& peer_public_value,
-                                  std::string* shared_key) const OVERRIDE;
-  virtual base::StringPiece public_value() const OVERRIDE;
-  virtual QuicTag tag() const OVERRIDE;
+                                  std::string* shared_key) const override;
+  virtual base::StringPiece public_value() const override;
+  virtual QuicTag tag() const override;
 
  private:
   enum {
diff --git a/net/quic/crypto/proof_source_chromium.h b/net/quic/crypto/proof_source_chromium.h
index 70ab92d..3d1849e 100644
--- a/net/quic/crypto/proof_source_chromium.h
+++ b/net/quic/crypto/proof_source_chromium.h
@@ -27,7 +27,7 @@
                         const std::string& server_config,
                         bool ecdsa_ok,
                         const std::vector<std::string>** out_certs,
-                        std::string* out_signature) OVERRIDE;
+                        std::string* out_signature) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProofSourceChromium);
diff --git a/net/quic/crypto/proof_test.cc b/net/quic/crypto/proof_test.cc
index 031cba2..0dde97c 100644
--- a/net/quic/crypto/proof_test.cc
+++ b/net/quic/crypto/proof_test.cc
@@ -40,7 +40,7 @@
 
   virtual void Run(bool ok,
                    const string& error_details,
-                   scoped_ptr<ProofVerifyDetails>* details) OVERRIDE {
+                   scoped_ptr<ProofVerifyDetails>* details) override {
     *ok_ = ok;
     *error_details_ = error_details;
 
diff --git a/net/quic/crypto/proof_verifier_chromium.h b/net/quic/crypto/proof_verifier_chromium.h
index 7b305e2..057cc16 100644
--- a/net/quic/crypto/proof_verifier_chromium.h
+++ b/net/quic/crypto/proof_verifier_chromium.h
@@ -30,7 +30,7 @@
  public:
 
   // ProofVerifyDetails implementation
-  virtual ProofVerifyDetails* Clone() const OVERRIDE;
+  virtual ProofVerifyDetails* Clone() const override;
 
   CertVerifyResult cert_verify_result;
 
@@ -67,7 +67,7 @@
       const ProofVerifyContext* verify_context,
       std::string* error_details,
       scoped_ptr<ProofVerifyDetails>* verify_details,
-      ProofVerifierCallback* callback) OVERRIDE;
+      ProofVerifierCallback* callback) override;
 
  private:
   class Job;
diff --git a/net/quic/crypto/quic_crypto_client_config.cc b/net/quic/crypto/quic_crypto_client_config.cc
index 90dc265..1f668af 100644
--- a/net/quic/crypto/quic_crypto_client_config.cc
+++ b/net/quic/crypto/quic_crypto_client_config.cc
@@ -56,7 +56,9 @@
 }  // namespace
 
 QuicCryptoClientConfig::QuicCryptoClientConfig()
-    : disable_ecdsa_(false) {}
+    : disable_ecdsa_(false) {
+  SetDefaults();
+}
 
 QuicCryptoClientConfig::~QuicCryptoClientConfig() {
   STLDeleteValues(&cached_states_);
diff --git a/net/quic/crypto/quic_crypto_client_config.h b/net/quic/crypto/quic_crypto_client_config.h
index 39c2508..9fc8ff0 100644
--- a/net/quic/crypto/quic_crypto_client_config.h
+++ b/net/quic/crypto/quic_crypto_client_config.h
@@ -133,9 +133,6 @@
   QuicCryptoClientConfig();
   ~QuicCryptoClientConfig();
 
-  // Sets the members to reasonable, default values.
-  void SetDefaults();
-
   // LookupOrCreate returns a CachedState for the given |server_id|. If no such
   // CachedState currently exists, it will be created and cached.
   CachedState* LookupOrCreate(const QuicServerId& server_id);
@@ -269,6 +266,9 @@
  private:
   typedef std::map<QuicServerId, CachedState*> CachedStateMap;
 
+  // Sets the members to reasonable, default values.
+  void SetDefaults();
+
   // CacheNewServerConfig checks for SCFG, STK, PROF, and CRT tags in |message|,
   // verifies them, and stores them in the cached state if they validate.
   // This is used on receipt of a REJ from a server, or when a server sends
diff --git a/net/quic/crypto/quic_crypto_client_config_test.cc b/net/quic/crypto/quic_crypto_client_config_test.cc
index b02243b..d2c4920 100644
--- a/net/quic/crypto/quic_crypto_client_config_test.cc
+++ b/net/quic/crypto/quic_crypto_client_config_test.cc
@@ -21,7 +21,7 @@
   virtual ~TestProofVerifyDetails() {}
 
   // ProofVerifyDetails implementation
-  virtual ProofVerifyDetails* Clone() const OVERRIDE {
+  virtual ProofVerifyDetails* Clone() const override {
     return new TestProofVerifyDetails;
   }
 };
@@ -81,7 +81,6 @@
 
 TEST(QuicCryptoClientConfigTest, PreferAesGcm) {
   QuicCryptoClientConfig config;
-  config.SetDefaults();
   if (config.aead.size() > 1)
     EXPECT_NE(kAESG, config.aead[0]);
   config.PreferAesGcm();
diff --git a/net/quic/crypto/quic_crypto_server_config.cc b/net/quic/crypto/quic_crypto_server_config.cc
index 6281043..d5a2b75 100644
--- a/net/quic/crypto/quic_crypto_server_config.cc
+++ b/net/quic/crypto/quic_crypto_server_config.cc
@@ -18,6 +18,7 @@
 #include "net/quic/crypto/chacha20_poly1305_encrypter.h"
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/crypto_framer.h"
+#include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/crypto/crypto_utils.h"
 #include "net/quic/crypto/curve25519_key_exchange.h"
@@ -61,49 +62,6 @@
 
 }  // namespace
 
-// ClientHelloInfo contains information about a client hello message that is
-// only kept for as long as it's being processed.
-struct ClientHelloInfo {
-  ClientHelloInfo(const IPEndPoint& in_client_ip, QuicWallTime in_now)
-      : client_ip(in_client_ip),
-        now(in_now),
-        valid_source_address_token(false),
-        client_nonce_well_formed(false),
-        unique(false) {}
-
-  // Inputs to EvaluateClientHello.
-  const IPEndPoint client_ip;
-  const QuicWallTime now;
-
-  // Outputs from EvaluateClientHello.
-  bool valid_source_address_token;
-  bool client_nonce_well_formed;
-  bool unique;
-  StringPiece sni;
-  StringPiece client_nonce;
-  StringPiece server_nonce;
-  StringPiece user_agent_id;
-
-  // Errors from EvaluateClientHello.
-  vector<uint32> reject_reasons;
-  COMPILE_ASSERT(sizeof(QuicTag) == sizeof(uint32), header_out_of_sync);
-};
-
-struct ValidateClientHelloResultCallback::Result {
-  Result(const CryptoHandshakeMessage& in_client_hello,
-         IPEndPoint in_client_ip,
-         QuicWallTime in_now)
-      : client_hello(in_client_hello),
-        info(in_client_ip, in_now),
-        error_code(QUIC_NO_ERROR) {
-  }
-
-  CryptoHandshakeMessage client_hello;
-  ClientHelloInfo info;
-  QuicErrorCode error_code;
-  string error_details;
-};
-
 class ValidateClientHelloHelper {
  public:
   ValidateClientHelloHelper(ValidateClientHelloResultCallback::Result* result,
@@ -150,7 +108,7 @@
 
  protected:
   virtual void RunImpl(bool nonce_is_valid_and_unique,
-                       InsertStatus nonce_error) OVERRIDE {
+                       InsertStatus nonce_error) override {
     DVLOG(1) << "Using client nonce, unique: " << nonce_is_valid_and_unique
              << " nonce_error: " << nonce_error;
     result_->info.unique = nonce_is_valid_and_unique;
@@ -199,12 +157,36 @@
 // static
 const char QuicCryptoServerConfig::TESTING[] = "secret string for testing";
 
+ClientHelloInfo::ClientHelloInfo(const IPEndPoint& in_client_ip,
+                                 QuicWallTime in_now)
+    : client_ip(in_client_ip),
+      now(in_now),
+      valid_source_address_token(false),
+      client_nonce_well_formed(false),
+      unique(false) {
+}
+
+ClientHelloInfo::~ClientHelloInfo() {
+}
+
 PrimaryConfigChangedCallback::PrimaryConfigChangedCallback() {
 }
 
 PrimaryConfigChangedCallback::~PrimaryConfigChangedCallback() {
 }
 
+ValidateClientHelloResultCallback::Result::Result(
+    const CryptoHandshakeMessage& in_client_hello,
+    IPEndPoint in_client_ip,
+    QuicWallTime in_now)
+    : client_hello(in_client_hello),
+      info(in_client_ip, in_now),
+      error_code(QUIC_NO_ERROR) {
+}
+
+ValidateClientHelloResultCallback::Result::~Result() {
+}
+
 ValidateClientHelloResultCallback::ValidateClientHelloResultCallback() {
 }
 
@@ -603,8 +585,9 @@
       !info.client_nonce_well_formed ||
       !info.unique ||
       !requested_config.get()) {
-    BuildRejection(
-        *primary_config.get(), client_hello, info, rand, params, out);
+    BuildRejection(*primary_config.get(), client_hello, info,
+                   validate_chlo_result.cached_network_params, rand, params,
+                   out);
     return QUIC_NO_ERROR;
   }
 
@@ -773,13 +756,12 @@
         (QuicVersionToQuicTag(supported_versions[i]));
   }
   out->SetVector(kVER, supported_version_tags);
-  out->SetStringPiece(
-      kSourceAddressTokenTag,
-      NewSourceAddressToken(*requested_config.get(),
-                            client_address,
-                            rand,
-                            info.now,
-                            nullptr));
+  out->SetStringPiece(kSourceAddressTokenTag,
+                      NewSourceAddressToken(*requested_config.get(),
+                                            client_address,
+                                            rand,
+                                            info.now,
+                                            nullptr));
   QuicSocketAddressCoder address_coder(client_address);
   out->SetStringPiece(kCADR, address_coder.Encode());
   out->SetStringPiece(kPUBS, forward_secure_public_value);
@@ -949,8 +931,12 @@
   HandshakeFailureReason source_address_token_error;
   StringPiece srct;
   if (client_hello.GetStringPiece(kSourceAddressTokenTag, &srct)) {
-    source_address_token_error = ValidateSourceAddressToken(
-        *requested_config.get(), srct, info->client_ip, info->now);
+    source_address_token_error =
+        ValidateSourceAddressToken(*requested_config.get(),
+                                   srct,
+                                   info->client_ip,
+                                   info->now,
+                                   &client_hello_state->cached_network_params);
     info->valid_source_address_token =
         (source_address_token_error == HANDSHAKE_OK);
   } else {
@@ -1083,6 +1069,7 @@
     const Config& config,
     const CryptoHandshakeMessage& client_hello,
     const ClientHelloInfo& info,
+    const CachedNetworkParameters& cached_network_params,
     QuicRandom* rand,
     QuicCryptoNegotiatedParameters *params,
     CryptoHandshakeMessage* out) const {
@@ -1094,7 +1081,7 @@
                           info.client_ip,
                           rand,
                           info.now,
-                          nullptr));
+                          &cached_network_params));
   if (replay_protection_) {
     out->SetStringPiece(kServerNonceTag, NewServerNonce(rand, info.now));
   }
@@ -1437,7 +1424,8 @@
     const Config& config,
     StringPiece token,
     const IPEndPoint& ip,
-    QuicWallTime now) const {
+    QuicWallTime now,
+    CachedNetworkParameters* cached_network_params) const {
   string storage;
   StringPiece plaintext;
   if (!config.source_address_token_boxer->Unbox(token, &storage, &plaintext)) {
@@ -1473,6 +1461,11 @@
     return SOURCE_ADDRESS_TOKEN_EXPIRED_FAILURE;
   }
 
+  if (FLAGS_quic_store_cached_network_params_from_chlo &&
+      source_address_token.has_cached_network_parameters()) {
+    *cached_network_params = source_address_token.cached_network_parameters();
+  }
+
   return HANDSHAKE_OK;
 }
 
diff --git a/net/quic/crypto/quic_crypto_server_config.h b/net/quic/crypto/quic_crypto_server_config.h
index ef8f6e9..30e0f6d 100644
--- a/net/quic/crypto/quic_crypto_server_config.h
+++ b/net/quic/crypto/quic_crypto_server_config.h
@@ -36,7 +36,29 @@
 class StrikeRegister;
 class StrikeRegisterClient;
 
-struct ClientHelloInfo;
+// ClientHelloInfo contains information about a client hello message that is
+// only kept for as long as it's being processed.
+struct ClientHelloInfo {
+  ClientHelloInfo(const IPEndPoint& in_client_ip, QuicWallTime in_now);
+  ~ClientHelloInfo();
+
+  // Inputs to EvaluateClientHello.
+  const IPEndPoint client_ip;
+  const QuicWallTime now;
+
+  // Outputs from EvaluateClientHello.
+  bool valid_source_address_token;
+  bool client_nonce_well_formed;
+  bool unique;
+  base::StringPiece sni;
+  base::StringPiece client_nonce;
+  base::StringPiece server_nonce;
+  base::StringPiece user_agent_id;
+
+  // Errors from EvaluateClientHello.
+  std::vector<uint32> reject_reasons;
+  COMPILE_ASSERT(sizeof(QuicTag) == sizeof(uint32), header_out_of_sync);
+};
 
 namespace test {
 class QuicCryptoServerConfigPeer;
@@ -58,7 +80,20 @@
  public:
   // Opaque token that holds information about the client_hello and
   // its validity.  Can be interpreted by calling ProcessClientHello.
-  struct Result;
+  struct Result {
+    Result(const CryptoHandshakeMessage& in_client_hello,
+           IPEndPoint in_client_ip,
+           QuicWallTime in_now);
+    ~Result();
+
+    CryptoHandshakeMessage client_hello;
+    ClientHelloInfo info;
+    QuicErrorCode error_code;
+    std::string error_details;
+
+    // Populated if the CHLO STK contained a CachedNetworkParameters proto.
+    CachedNetworkParameters cached_network_params;
+  };
 
   ValidateClientHelloResultCallback();
   virtual ~ValidateClientHelloResultCallback();
@@ -386,6 +421,7 @@
       const Config& config,
       const CryptoHandshakeMessage& client_hello,
       const ClientHelloInfo& info,
+      const CachedNetworkParameters& cached_network_params,
       QuicRandom* rand,
       QuicCryptoNegotiatedParameters *params,
       CryptoHandshakeMessage* out) const;
@@ -407,10 +443,14 @@
   // ValidateSourceAddressToken returns HANDSHAKE_OK if the source address token
   // in |token| is a valid and timely token for the IP address |ip| given that
   // the current time is |now|. Otherwise it returns the reason for failure.
-  HandshakeFailureReason ValidateSourceAddressToken(const Config& config,
-                                                    base::StringPiece token,
-                                                    const IPEndPoint& ip,
-                                                    QuicWallTime now) const;
+  // |cached_network_params| is populated if |token| contains a
+  // CachedNetworkParameters proto.
+  HandshakeFailureReason ValidateSourceAddressToken(
+      const Config& config,
+      base::StringPiece token,
+      const IPEndPoint& ip,
+      QuicWallTime now,
+      CachedNetworkParameters* cached_network_params) const;
 
   // NewServerNonce generates and encrypts a random nonce.
   std::string NewServerNonce(QuicRandom* rand, QuicWallTime now) const;
diff --git a/net/quic/crypto/quic_crypto_server_config_test.cc b/net/quic/crypto/quic_crypto_server_config_test.cc
index f44dc5c..59d6cf4 100644
--- a/net/quic/crypto/quic_crypto_server_config_test.cc
+++ b/net/quic/crypto/quic_crypto_server_config_test.cc
@@ -13,6 +13,7 @@
 #include "net/quic/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/crypto/strike_register_client.h"
+#include "net/quic/quic_flags.h"
 #include "net/quic/quic_time.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ -52,19 +53,37 @@
 
   string NewSourceAddressToken(
       string config_id,
-      IPEndPoint ip,
+      const IPEndPoint& ip,
       QuicRandom* rand,
       QuicWallTime now) {
+    return NewSourceAddressToken(config_id, ip, rand, now, NULL);
+  }
+
+  string NewSourceAddressToken(
+      string config_id,
+      const IPEndPoint& ip,
+      QuicRandom* rand,
+      QuicWallTime now,
+      CachedNetworkParameters* cached_network_params) {
     return server_config_->NewSourceAddressToken(
-        *GetConfig(config_id), ip, rand, now, nullptr);
+        *GetConfig(config_id), ip, rand, now, cached_network_params);
   }
 
   HandshakeFailureReason ValidateSourceAddressToken(string config_id,
                                                     StringPiece srct,
-                                                    IPEndPoint ip,
+                                                    const IPEndPoint& ip,
                                                     QuicWallTime now) {
+    return ValidateSourceAddressToken(config_id, srct, ip, now, NULL);
+  }
+
+  HandshakeFailureReason ValidateSourceAddressToken(
+      string config_id,
+      StringPiece srct,
+      const IPEndPoint& ip,
+      QuicWallTime now,
+      CachedNetworkParameters* cached_network_params) {
     return server_config_->ValidateSourceAddressToken(
-        *GetConfig(config_id), srct, ip, now);
+        *GetConfig(config_id), srct, ip, now, cached_network_params);
   }
 
   string NewServerNonce(QuicRandom* rand, QuicWallTime now) const {
@@ -188,7 +207,7 @@
         is_known_orbit_called_(false) {
   }
 
-  virtual bool IsKnownOrbit(StringPiece orbit) const OVERRIDE {
+  virtual bool IsKnownOrbit(StringPiece orbit) const override {
     // Ensure that the strike register client lock is not held.
     QuicCryptoServerConfigPeer peer(config_);
     base::Lock* m = peer.GetStrikeRegisterClientLock();
@@ -204,7 +223,7 @@
   virtual void VerifyNonceIsValidAndUnique(
       StringPiece nonce,
       QuicWallTime now,
-      ResultCallback* cb) OVERRIDE {
+      ResultCallback* cb) override {
     LOG(FATAL) << "Not implemented";
   }
 
@@ -241,6 +260,8 @@
 }
 
 TEST(QuicCryptoServerConfigTest, SourceAddressTokens) {
+  ValueRestore<bool> old_flag(&FLAGS_quic_store_cached_network_params_from_chlo,
+                              true);
   const string kPrimary = "<primary>";
   const string kOverride = "Config with custom source address token key";
 
@@ -329,6 +350,21 @@
   now = original_time.Subtract(QuicTime::Delta::FromSeconds(3600 * 2));
   DCHECK_EQ(SOURCE_ADDRESS_TOKEN_CLOCK_SKEW_FAILURE,
             peer.ValidateSourceAddressToken(kPrimary, token4, ip4, now));
+
+  // Make sure that if the source address token contains CachedNetworkParameters
+  // that this gets written to ValidateSourceAddressToken output argument.
+  CachedNetworkParameters cached_network_params_input;
+  cached_network_params_input.set_bandwidth_estimate_bytes_per_second(1234);
+  const string token4_with_cached_network_params = peer.NewSourceAddressToken(
+      kPrimary, ip4, rand, now, &cached_network_params_input);
+
+  CachedNetworkParameters cached_network_params_output;
+  EXPECT_NE(cached_network_params_output, cached_network_params_input);
+  peer.ValidateSourceAddressToken(kPrimary, token4_with_cached_network_params,
+                                  ip4, now, &cached_network_params_output);
+  // TODO(rtenneti): For server, enable the following check after serialization
+  // of optional CachedNetworkParameters is implemented.
+  // EXPECT_EQ(cached_network_params_output, cached_network_params_input);
 }
 
 TEST(QuicCryptoServerConfigTest, ValidateServerNonce) {
diff --git a/net/quic/crypto/quic_random.cc b/net/quic/crypto/quic_random.cc
index 6f46013..bc85c2d 100644
--- a/net/quic/crypto/quic_random.cc
+++ b/net/quic/crypto/quic_random.cc
@@ -17,10 +17,10 @@
   static DefaultRandom* GetInstance();
 
   // QuicRandom implementation
-  virtual void RandBytes(void* data, size_t len) OVERRIDE;
-  virtual uint64 RandUint64() OVERRIDE;
+  virtual void RandBytes(void* data, size_t len) override;
+  virtual uint64 RandUint64() override;
   virtual void Reseed(const void* additional_entropy,
-                      size_t entropy_len) OVERRIDE;
+                      size_t entropy_len) override;
 
  private:
   DefaultRandom() {};
diff --git a/net/quic/crypto/source_address_token.cc b/net/quic/crypto/source_address_token.cc
index f20c343..7ac43f0 100644
--- a/net/quic/crypto/source_address_token.cc
+++ b/net/quic/crypto/source_address_token.cc
@@ -14,13 +14,39 @@
 
 namespace net {
 
-CachedNetworkParameters::CachedNetworkParameters() {
+CachedNetworkParameters::CachedNetworkParameters()
+    : bandwidth_estimate_bytes_per_second_(0),
+      max_bandwidth_estimate_bytes_per_second_(0),
+      max_bandwidth_timestamp_seconds_(0),
+      min_rtt_ms_(0),
+      previous_connection_state_(0),
+      timestamp_(0) {
 }
 
 CachedNetworkParameters::~CachedNetworkParameters() {
 }
 
-SourceAddressToken::SourceAddressToken() {
+bool CachedNetworkParameters::operator==(
+    const CachedNetworkParameters& other) const {
+  return serving_region_ == other.serving_region_ &&
+      bandwidth_estimate_bytes_per_second_ ==
+          other.bandwidth_estimate_bytes_per_second_ &&
+      max_bandwidth_estimate_bytes_per_second_ ==
+          other.max_bandwidth_estimate_bytes_per_second_ &&
+      max_bandwidth_timestamp_seconds_ ==
+          other.max_bandwidth_timestamp_seconds_ &&
+      min_rtt_ms_ == other.min_rtt_ms_ &&
+      previous_connection_state_ == other.previous_connection_state_ &&
+      timestamp_ == other.timestamp_;
+}
+
+bool CachedNetworkParameters::operator!=(
+    const CachedNetworkParameters& other) const {
+  return !(*this == other);
+}
+
+SourceAddressToken::SourceAddressToken()
+    : has_cached_network_parameters_(false) {
 }
 
 SourceAddressToken::~SourceAddressToken() {
diff --git a/net/quic/crypto/source_address_token.h b/net/quic/crypto/source_address_token.h
index 1101351..76c3454 100644
--- a/net/quic/crypto/source_address_token.h
+++ b/net/quic/crypto/source_address_token.h
@@ -28,6 +28,9 @@
   CachedNetworkParameters();
   ~CachedNetworkParameters();
 
+  bool operator==(const CachedNetworkParameters& other) const;
+  bool operator!=(const CachedNetworkParameters& other) const;
+
   std::string serving_region() const {
     return serving_region_;
   }
@@ -133,6 +136,10 @@
   void set_cached_network_parameters(
       const CachedNetworkParameters& cached_network_parameters) {
     cached_network_parameters_ = cached_network_parameters;
+    has_cached_network_parameters_ = true;
+  }
+  bool has_cached_network_parameters() const {
+    return has_cached_network_parameters_;
   }
 
  private:
@@ -146,6 +153,9 @@
   // The server can provide estimated network parameters to be used for
   // initial parameter selection in future connections.
   CachedNetworkParameters cached_network_parameters_;
+  // TODO(rtenneti): Delete |has_cached_network_parameters_| after we convert
+  // SourceAddressToken to protobuf.
+  bool has_cached_network_parameters_;
 
   DISALLOW_COPY_AND_ASSIGN(SourceAddressToken);
 };
diff --git a/net/quic/quic_ack_notifier_manager.h b/net/quic/quic_ack_notifier_manager.h
index bf5b345..122bda1 100644
--- a/net/quic/quic_ack_notifier_manager.h
+++ b/net/quic/quic_ack_notifier_manager.h
@@ -10,17 +10,6 @@
 #include "base/containers/hash_tables.h"
 #include "net/quic/quic_protocol.h"
 
-#if defined(COMPILER_GCC)
-namespace BASE_HASH_NAMESPACE {
-template<>
-struct hash<net::QuicAckNotifier*> {
-  std::size_t operator()(const net::QuicAckNotifier* ptr) const {
-    return hash<size_t>()(reinterpret_cast<size_t>(ptr));
-  }
-};
-}
-#endif
-
 namespace net {
 
 class QuicAckNotifier;
diff --git a/net/quic/quic_alarm_test.cc b/net/quic/quic_alarm_test.cc
index 434bb38..47e23e3 100644
--- a/net/quic/quic_alarm_test.cc
+++ b/net/quic/quic_alarm_test.cc
@@ -32,12 +32,12 @@
   }
 
  protected:
-  virtual void SetImpl() OVERRIDE {
+  virtual void SetImpl() override {
     DCHECK(deadline().IsInitialized());
     scheduled_ = true;
   }
 
-  virtual void CancelImpl() OVERRIDE {
+  virtual void CancelImpl() override {
     DCHECK(!deadline().IsInitialized());
     scheduled_ = false;
   }
diff --git a/net/quic/quic_client_session.cc b/net/quic/quic_client_session.cc
index 5454c10..b7e8185 100644
--- a/net/quic/quic_client_session.cc
+++ b/net/quic/quic_client_session.cc
@@ -153,7 +153,7 @@
       num_total_streams_(0),
       task_runner_(task_runner),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_QUIC_SESSION)),
-      logger_(new QuicConnectionLogger(net_log_)),
+      logger_(new QuicConnectionLogger(this, net_log_)),
       num_packets_read_(0),
       going_away_(false),
       weak_factory_(this) {
@@ -265,14 +265,14 @@
   const QuicConnectionStats stats = connection()->GetStats();
   if (stats.max_sequence_reordering == 0)
     return;
-  const uint64 kMaxReordering = 100;
-  uint64 reordering = kMaxReordering;
-  if (stats.min_rtt_us > 0 ) {
-    reordering =
-        GG_UINT64_C(100) * stats.max_time_reordering_us / stats.min_rtt_us;
+  const base::HistogramBase::Sample kMaxReordering = 100;
+  base::HistogramBase::Sample reordering = kMaxReordering;
+  if (stats.min_rtt_us > 0) {
+    reordering = static_cast<base::HistogramBase::Sample>(
+        100 * stats.max_time_reordering_us / stats.min_rtt_us);
   }
   UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.MaxReorderingTime",
-                                reordering, 0, kMaxReordering, 50);
+                              reordering, 0, kMaxReordering, 50);
   if (stats.min_rtt_us > 100 * 1000) {
     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.QuicSession.MaxReorderingTimeLongRtt",
                                 reordering, 0, kMaxReordering, 50);
diff --git a/net/quic/quic_client_session.h b/net/quic/quic_client_session.h
index fa712c2..430ef52 100644
--- a/net/quic/quic_client_session.h
+++ b/net/quic/quic_client_session.h
@@ -124,30 +124,30 @@
 
   // QuicSession methods:
   virtual void OnStreamFrames(
-      const std::vector<QuicStreamFrame>& frames) OVERRIDE;
-  virtual QuicReliableClientStream* CreateOutgoingDataStream() OVERRIDE;
-  virtual QuicCryptoClientStream* GetCryptoStream() OVERRIDE;
-  virtual void CloseStream(QuicStreamId stream_id) OVERRIDE;
+      const std::vector<QuicStreamFrame>& frames) override;
+  virtual QuicReliableClientStream* CreateOutgoingDataStream() override;
+  virtual QuicCryptoClientStream* GetCryptoStream() override;
+  virtual void CloseStream(QuicStreamId stream_id) override;
   virtual void SendRstStream(QuicStreamId id,
                              QuicRstStreamErrorCode error,
-                             QuicStreamOffset bytes_written) OVERRIDE;
-  virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) OVERRIDE;
+                             QuicStreamOffset bytes_written) override;
+  virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
   virtual void OnCryptoHandshakeMessageSent(
-      const CryptoHandshakeMessage& message) OVERRIDE;
+      const CryptoHandshakeMessage& message) override;
   virtual void OnCryptoHandshakeMessageReceived(
-      const CryptoHandshakeMessage& message) OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) const OVERRIDE;
+      const CryptoHandshakeMessage& message) override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) const override;
 
   // QuicClientSessionBase methods:
   virtual void OnProofValid(
-      const QuicCryptoClientConfig::CachedState& cached) OVERRIDE;
+      const QuicCryptoClientConfig::CachedState& cached) override;
   virtual void OnProofVerifyDetailsAvailable(
-      const ProofVerifyDetails& verify_details) OVERRIDE;
+      const ProofVerifyDetails& verify_details) override;
 
   // QuicConnectionVisitorInterface methods:
-  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
+  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
   virtual void OnSuccessfulVersionNegotiation(
-      const QuicVersion& version) OVERRIDE;
+      const QuicVersion& version) override;
 
   // Performs a crypto handshake with the server.
   int CryptoConnect(bool require_confirmation,
@@ -182,7 +182,7 @@
 
  protected:
   // QuicSession methods:
-  virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE;
+  virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) override;
 
  private:
   friend class test::QuicClientSessionPeer;
diff --git a/net/quic/quic_client_session_base.h b/net/quic/quic_client_session_base.h
index 834d006..ae0644e 100644
--- a/net/quic/quic_client_session_base.h
+++ b/net/quic/quic_client_session_base.h
@@ -33,7 +33,7 @@
       const ProofVerifyDetails& verify_details) = 0;
 
   // Override base class to set FEC policy before any data is sent by client.
-  virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) OVERRIDE;
+  virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicClientSessionBase);
diff --git a/net/quic/quic_client_session_test.cc b/net/quic/quic_client_session_test.cc
index 9758ed4..b1cfe3d 100644
--- a/net/quic/quic_client_session_test.cc
+++ b/net/quic/quic_client_session_test.cc
@@ -51,11 +51,9 @@
     session_.InitializeSession(QuicServerId(kServerHostname, kServerPort, false,
                                             PRIVACY_MODE_DISABLED),
                                 &crypto_config_, nullptr);
-    session_.config()->SetDefaults();
-    crypto_config_.SetDefaults();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     session_.CloseSessionOnError(ERR_ABORTED);
   }
 
diff --git a/net/quic/quic_config.cc b/net/quic/quic_config.cc
index 5330b7c..7b7976c 100644
--- a/net/quic/quic_config.cc
+++ b/net/quic/quic_config.cc
@@ -427,6 +427,7 @@
 QuicConfig::QuicConfig()
     : max_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
       max_idle_time_before_crypto_handshake_(QuicTime::Delta::Zero()),
+      max_undecryptable_packets_(0),
       congestion_feedback_(kCGST, PRESENCE_REQUIRED),
       connection_options_(kCOPT, PRESENCE_OPTIONAL),
       idle_connection_state_lifetime_seconds_(kICSL, PRESENCE_REQUIRED),
@@ -443,6 +444,7 @@
       // QUIC_VERSION_19.
       initial_session_flow_control_window_bytes_(kCFCW, PRESENCE_OPTIONAL),
       socket_receive_buffer_(kSRBF, PRESENCE_OPTIONAL) {
+  SetDefaults();
 }
 
 QuicConfig::~QuicConfig() {}
@@ -643,6 +645,7 @@
       QuicTime::Delta::FromSeconds(kMaxTimeForCryptoHandshakeSecs);
   max_idle_time_before_crypto_handshake_ =
       QuicTime::Delta::FromSeconds(kInitialIdleTimeoutSecs);
+  max_undecryptable_packets_ = kDefaultMaxUndecryptablePackets;
 
   SetInitialFlowControlWindowToSend(kDefaultFlowControlSendWindow);
   SetInitialStreamFlowControlWindowToSend(kDefaultFlowControlSendWindow);
diff --git a/net/quic/quic_config.h b/net/quic/quic_config.h
index 203eb2e..7be4569 100644
--- a/net/quic/quic_config.h
+++ b/net/quic/quic_config.h
@@ -89,7 +89,7 @@
 
   // Serialises |name_| and value to |out|. If |negotiated_| is true then
   // |negotiated_value_| is serialised, otherwise |max_value_| is serialised.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |negotiated_value_| to the minimum of |max_value_| and the
   // corresponding value from |peer_hello|. If the corresponding value is
@@ -98,7 +98,7 @@
   virtual QuicErrorCode ProcessPeerHello(
       const CryptoHandshakeMessage& peer_hello,
       HelloType hello_type,
-      std::string* error_details) OVERRIDE;
+      std::string* error_details) override;
 
  private:
   uint32 max_value_;
@@ -123,7 +123,7 @@
   // Serialises |name_| and vector (either possible or negotiated) to |out|. If
   // |negotiated_| is true then |negotiated_tag_| is serialised, otherwise
   // |possible_values_| is serialised.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Selects the tag common to both tags in |client_hello| for |name_| and
   // |possible_values_| with preference to tag in |possible_values_|. The
@@ -131,7 +131,7 @@
   virtual QuicErrorCode ProcessPeerHello(
       const CryptoHandshakeMessage& peer_hello,
       HelloType hello_type,
-      std::string* error_details) OVERRIDE;
+      std::string* error_details) override;
 
  private:
   // Reads the vector corresponding to |name_| from |msg| into |out|. If the
@@ -166,13 +166,13 @@
   void SetReceivedValue(uint32 value);
 
   // If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |value_| to the corresponding value from |peer_hello_| if it exists.
   virtual QuicErrorCode ProcessPeerHello(
       const CryptoHandshakeMessage& peer_hello,
       HelloType hello_type,
-      std::string* error_details) OVERRIDE;
+      std::string* error_details) override;
 
  private:
   uint32 send_value_;
@@ -200,13 +200,13 @@
   void SetReceivedValue(QuicTag value);
 
   // If has_send_value is true, serialises |tag_| and |send_value_| to |out|.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |value_| to the corresponding value from |client_hello_| if it exists.
   virtual QuicErrorCode ProcessPeerHello(
       const CryptoHandshakeMessage& peer_hello,
       HelloType hello_type,
-      std::string* error_details) OVERRIDE;
+      std::string* error_details) override;
 
  private:
   QuicTag send_value_;
@@ -235,14 +235,14 @@
 
   // If has_send_value is true, serialises |tag_vector_| and |send_value_| to
   // |out|.
-  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const OVERRIDE;
+  virtual void ToHandshakeMessage(CryptoHandshakeMessage* out) const override;
 
   // Sets |receive_values_| to the corresponding value from |client_hello_| if
   // it exists.
   virtual QuicErrorCode ProcessPeerHello(
       const CryptoHandshakeMessage& peer_hello,
       HelloType hello_type,
-      std::string* error_details) OVERRIDE;
+      std::string* error_details) override;
 
  private:
   QuicTagVector send_values_;
@@ -304,6 +304,14 @@
     return max_idle_time_before_crypto_handshake_;
   }
 
+  void set_max_undecryptable_packets(size_t max_undecryptable_packets) {
+    max_undecryptable_packets_ = max_undecryptable_packets;
+  }
+
+  size_t max_undecryptable_packets() const {
+    return max_undecryptable_packets_;
+  }
+
   // Sets the peer's default initial congestion window in packets.
   void SetInitialCongestionWindowToSend(size_t initial_window);
 
@@ -362,9 +370,6 @@
 
   bool negotiated() const;
 
-  // SetDefaults sets the members to sensible, default values.
-  void SetDefaults();
-
   // ToHandshakeMessage serialises the settings in this object as a series of
   // tags /value pairs and adds them to |out|.
   void ToHandshakeMessage(CryptoHandshakeMessage* out) const;
@@ -378,11 +383,16 @@
  private:
   friend class test::QuicConfigPeer;
 
+  // SetDefaults sets the members to sensible, default values.
+  void SetDefaults();
+
   // Configurations options that are not negotiated.
   // Maximum time the session can be alive before crypto handshake is finished.
   QuicTime::Delta max_time_before_crypto_handshake_;
   // Maximum idle time before the crypto handshake has completed.
   QuicTime::Delta max_idle_time_before_crypto_handshake_;
+  // Maximum number of undecryptable packets stored before CHLO/SHLO.
+  size_t max_undecryptable_packets_;
 
   // Congestion control feedback type.
   QuicNegotiableTag congestion_feedback_;
diff --git a/net/quic/quic_config_test.cc b/net/quic/quic_config_test.cc
index 2263e44..914b137 100644
--- a/net/quic/quic_config_test.cc
+++ b/net/quic/quic_config_test.cc
@@ -22,15 +22,10 @@
 
 class QuicConfigTest : public ::testing::Test {
  protected:
-  QuicConfigTest() {
-    config_.SetDefaults();
-  }
-
   QuicConfig config_;
 };
 
 TEST_F(QuicConfigTest, ToHandshakeMessage) {
-  config_.SetDefaults();
   config_.SetInitialFlowControlWindowToSend(
       kInitialSessionFlowControlWindowForTest);
   config_.SetInitialStreamFlowControlWindowToSend(
@@ -265,7 +260,6 @@
 
 TEST_F(QuicConfigTest, NoOverLapInCGST) {
   QuicConfig server_config;
-  server_config.SetDefaults();
   QuicTagVector cgst;
   cgst.push_back(kTBBR);
   server_config.SetCongestionFeedback(cgst, kTBBR);
diff --git a/net/quic/quic_connection.cc b/net/quic/quic_connection.cc
index 8d49010..f684cf2 100644
--- a/net/quic/quic_connection.cc
+++ b/net/quic/quic_connection.cc
@@ -6,6 +6,7 @@
 
 #include <string.h>
 #include <sys/types.h>
+
 #include <algorithm>
 #include <iterator>
 #include <limits>
@@ -53,10 +54,6 @@
 // that this becomes limiting, we can revisit.
 const size_t kMaxFecGroups = 2;
 
-// Limit the number of undecryptable packets we buffer in
-// expectation of the CHLO/SHLO arriving.
-const size_t kMaxUndecryptablePackets = 10;
-
 // Maximum number of acks received before sending an ack in response.
 const size_t kMaxPacketsReceivedBeforeAckSend = 20;
 
@@ -72,7 +69,7 @@
       : connection_(connection) {
   }
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     connection_->SendAck();
     return QuicTime::Zero();
   }
@@ -92,7 +89,7 @@
       : connection_(connection) {
   }
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     connection_->OnRetransmissionTimeout();
     return QuicTime::Zero();
   }
@@ -111,7 +108,7 @@
       : connection_(connection) {
   }
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     connection_->WriteIfNotBlocked();
     // Never reschedule the alarm, since CanWrite does that.
     return QuicTime::Zero();
@@ -129,7 +126,7 @@
       : connection_(connection) {
   }
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     connection_->CheckForTimeout();
     // Never reschedule the alarm, since CheckForTimeout does that.
     return QuicTime::Zero();
@@ -147,7 +144,7 @@
       : connection_(connection) {
   }
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     connection_->SendPing();
     return QuicTime::Zero();
   }
@@ -162,10 +159,10 @@
 
 QuicConnection::QueuedPacket::QueuedPacket(SerializedPacket packet,
                                            EncryptionLevel level)
-  : serialized_packet(packet),
-    encryption_level(level),
-    transmission_type(NOT_RETRANSMISSION),
-    original_sequence_number(0) {
+    : serialized_packet(packet),
+      encryption_level(level),
+      transmission_type(NOT_RETRANSMISSION),
+      original_sequence_number(0) {
 }
 
 QuicConnection::QueuedPacket::QueuedPacket(
@@ -204,6 +201,7 @@
       last_decrypted_packet_level_(ENCRYPTION_NONE),
       largest_seen_packet_with_ack_(0),
       largest_seen_packet_with_stop_waiting_(0),
+      max_undecryptable_packets_(0),
       pending_version_negotiation_packet_(false),
       received_packet_manager_(&stats_),
       ack_queued_(false),
@@ -271,6 +269,7 @@
     SetIdleNetworkTimeout(config.IdleConnectionStateLifetime());
   }
   sent_packet_manager_.SetFromConfig(config);
+  max_undecryptable_packets_ = config.max_undecryptable_packets();
 }
 
 bool QuicConnection::SelectMutualVersion(
@@ -1116,7 +1115,7 @@
     // because the CHLO or SHLO packet was lost.
     if (framer_.error() == QUIC_DECRYPTION_FAILURE) {
       if (encryption_level_ != ENCRYPTION_FORWARD_SECURE &&
-          undecryptable_packets_.size() < kMaxUndecryptablePackets) {
+          undecryptable_packets_.size() < max_undecryptable_packets_) {
         QueueUndecryptablePacket(packet);
       } else if (debug_visitor_.get() != nullptr) {
         debug_visitor_->OnUndecryptablePacket();
@@ -1176,8 +1175,7 @@
     return;
   }
 
-  {  // Limit the scope of the bundler.
-    // Set |include_ack| to false in bundler; ack inclusion happens elsewhere.
+  { // Limit the scope of the bundler. ACK inclusion happens elsewhere.
     ScopedPacketBundler bundler(this, NO_ACK);
     visitor_->OnCanWrite();
   }
@@ -1322,7 +1320,8 @@
   // If the scheduler requires a delay, then we can not send this packet now.
   if (!delay.IsZero()) {
     send_alarm_->Update(now.Add(delay), QuicTime::Delta::FromMilliseconds(1));
-    DVLOG(1) << "Delaying sending.";
+    DVLOG(1) << ENDPOINT << "Delaying sending " << delay.ToMilliseconds()
+             << "ms";
     return false;
   }
   send_alarm_->Cancel();
@@ -1408,15 +1407,6 @@
   if (result.error_code == ERR_IO_PENDING) {
     DCHECK_EQ(WRITE_STATUS_BLOCKED, result.status);
   }
-  if (debug_visitor_.get() != nullptr) {
-    // Pass the write result to the visitor.
-    debug_visitor_->OnPacketSent(sequence_number,
-                                 packet->original_sequence_number,
-                                 packet->encryption_level,
-                                 packet->transmission_type,
-                                 *encrypted,
-                                 result);
-  }
 
   if (result.status == WRITE_STATUS_BLOCKED) {
     visitor_->OnWriteBlocked();
@@ -1429,6 +1419,15 @@
     }
   }
   QuicTime now = clock_->Now();
+  if (result.status != WRITE_STATUS_ERROR && debug_visitor_.get() != nullptr) {
+    // Pass the write result to the visitor.
+    debug_visitor_->OnPacketSent(packet->serialized_packet,
+                                 packet->original_sequence_number,
+                                 packet->encryption_level,
+                                 packet->transmission_type,
+                                 *encrypted,
+                                 now);
+  }
   if (packet->transmission_type == NOT_RETRANSMISSION) {
     time_of_last_sent_new_packet_ = now;
   }
@@ -1857,7 +1856,7 @@
   // Adjust the idle timeout on client and server to prevent clients from
   // sending requests to servers which have already closed the connection.
   if (is_server_) {
-    timeout = timeout.Add(QuicTime::Delta::FromSeconds(1));
+    timeout = timeout.Add(QuicTime::Delta::FromSeconds(3));
   } else if (timeout > QuicTime::Delta::FromSeconds(1)) {
     timeout = timeout.Subtract(QuicTime::Delta::FromSeconds(1));
   }
@@ -1895,7 +1894,7 @@
   // Adjust the idle timeout on client and server to prevent clients from
   // sending requests to servers which have already closed the connection.
   if (is_server_) {
-    idle_timeout = idle_timeout.Add(QuicTime::Delta::FromSeconds(1));
+    idle_timeout = idle_timeout.Add(QuicTime::Delta::FromSeconds(3));
   } else if (idle_timeout > QuicTime::Delta::FromSeconds(1)) {
     idle_timeout = idle_timeout.Subtract(QuicTime::Delta::FromSeconds(1));
   }
diff --git a/net/quic/quic_connection.h b/net/quic/quic_connection.h
index 0b017b0..fa117f8 100644
--- a/net/quic/quic_connection.h
+++ b/net/quic/quic_connection.h
@@ -124,12 +124,12 @@
   virtual ~QuicConnectionDebugVisitor() {}
 
   // Called when a packet has been sent.
-  virtual void OnPacketSent(QuicPacketSequenceNumber sequence_number,
+  virtual void OnPacketSent(const SerializedPacket& serialized_packet,
                             QuicPacketSequenceNumber original_sequence_number,
                             EncryptionLevel level,
                             TransmissionType transmission_type,
                             const QuicEncryptedPacket& packet,
-                            WriteResult result) {}
+                            QuicTime sent_time) {}
 
   // Called when a packet has been received, but before it is
   // validated or parsed.
@@ -299,7 +299,7 @@
   virtual void SendConnectionCloseWithDetails(QuicErrorCode error,
                                               const std::string& details);
   // Notifies the visitor of the close and marks the connection as disconnected.
-  virtual void CloseConnection(QuicErrorCode error, bool from_peer) OVERRIDE;
+  virtual void CloseConnection(QuicErrorCode error, bool from_peer) override;
   virtual void SendGoAway(QuicErrorCode error,
                           QuicStreamId last_good_stream_id,
                           const std::string& reason);
@@ -317,7 +317,7 @@
   // QuicBlockedWriterInterface
   // Called when the underlying connection becomes writable to allow queued
   // writes to happen.
-  virtual void OnCanWrite() OVERRIDE;
+  virtual void OnCanWrite() override;
 
   // Called when an error occurs while attempting to write a packet to the
   // network.
@@ -335,47 +335,47 @@
   }
 
   // From QuicFramerVisitorInterface
-  virtual void OnError(QuicFramer* framer) OVERRIDE;
-  virtual bool OnProtocolVersionMismatch(QuicVersion received_version) OVERRIDE;
-  virtual void OnPacket() OVERRIDE;
+  virtual void OnError(QuicFramer* framer) override;
+  virtual bool OnProtocolVersionMismatch(QuicVersion received_version) override;
+  virtual void OnPacket() override;
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE;
+      const QuicPublicResetPacket& packet) override;
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE;
-  virtual void OnRevivedPacket() OVERRIDE;
+      const QuicVersionNegotiationPacket& packet) override;
+  virtual void OnRevivedPacket() override;
   virtual bool OnUnauthenticatedPublicHeader(
-      const QuicPacketPublicHeader& header) OVERRIDE;
-  virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) OVERRIDE;
-  virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE;
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
-  virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE;
-  virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
-  virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
+      const QuicPacketPublicHeader& header) override;
+  virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
+  virtual void OnDecryptedPacket(EncryptionLevel level) override;
+  virtual bool OnPacketHeader(const QuicPacketHeader& header) override;
+  virtual void OnFecProtectedPayload(base::StringPiece payload) override;
+  virtual bool OnStreamFrame(const QuicStreamFrame& frame) override;
+  virtual bool OnAckFrame(const QuicAckFrame& frame) override;
   virtual bool OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE;
-  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE;
-  virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE;
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
+      const QuicCongestionFeedbackFrame& frame) override;
+  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
+  virtual bool OnPingFrame(const QuicPingFrame& frame) override;
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
   virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) OVERRIDE;
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
-  virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) OVERRIDE;
-  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE;
-  virtual void OnFecData(const QuicFecData& fec) OVERRIDE;
-  virtual void OnPacketComplete() OVERRIDE;
+      const QuicConnectionCloseFrame& frame) override;
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
+  virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
+  virtual void OnFecData(const QuicFecData& fec) override;
+  virtual void OnPacketComplete() override;
 
   // QuicPacketGenerator::DelegateInterface
   virtual bool ShouldGeneratePacket(TransmissionType transmission_type,
                                     HasRetransmittableData retransmittable,
-                                    IsHandshake handshake) OVERRIDE;
-  virtual QuicAckFrame* CreateAckFrame() OVERRIDE;
-  virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() OVERRIDE;
-  virtual QuicStopWaitingFrame* CreateStopWaitingFrame() OVERRIDE;
-  virtual void OnSerializedPacket(const SerializedPacket& packet) OVERRIDE;
+                                    IsHandshake handshake) override;
+  virtual QuicAckFrame* CreateAckFrame() override;
+  virtual QuicCongestionFeedbackFrame* CreateFeedbackFrame() override;
+  virtual QuicStopWaitingFrame* CreateStopWaitingFrame() override;
+  virtual void OnSerializedPacket(const SerializedPacket& packet) override;
 
   // QuicSentPacketManager::NetworkChangeVisitor
   virtual void OnCongestionWindowChange(
-      QuicByteCount congestion_window) OVERRIDE;
+      QuicByteCount congestion_window) override;
 
   // Called by the crypto stream when the handshake completes. In the server's
   // case this is when the SHLO has been ACKed. Clients call this on receipt of
@@ -713,6 +713,9 @@
   // sent with the INITIAL encryption and the CHLO message was lost.
   std::deque<QuicEncryptedPacket*> undecryptable_packets_;
 
+  // Maximum number of undecryptable packets the connection will store.
+  size_t max_undecryptable_packets_;
+
   // When the version negotiation packet could not be sent because the socket
   // was not writable, this is set to true.
   bool pending_version_negotiation_packet_;
diff --git a/net/quic/quic_connection_helper.cc b/net/quic/quic_connection_helper.cc
index fefd6fa..83c1648 100644
--- a/net/quic/quic_connection_helper.cc
+++ b/net/quic/quic_connection_helper.cc
@@ -29,7 +29,7 @@
         weak_factory_(this) {}
 
  protected:
-  virtual void SetImpl() OVERRIDE {
+  virtual void SetImpl() override {
     DCHECK(deadline().IsInitialized());
     if (task_deadline_.IsInitialized()) {
       if (task_deadline_ <= deadline()) {
@@ -54,7 +54,7 @@
     task_deadline_ = deadline();
   }
 
-  virtual void CancelImpl() OVERRIDE {
+  virtual void CancelImpl() override {
     DCHECK(!deadline().IsInitialized());
     // Since tasks can not be un-posted, OnAlarm will be invoked which
     // will notice that deadline is not Initialized and will do nothing.
diff --git a/net/quic/quic_connection_helper.h b/net/quic/quic_connection_helper.h
index 28cff52..e1754e5 100644
--- a/net/quic/quic_connection_helper.h
+++ b/net/quic/quic_connection_helper.h
@@ -37,9 +37,9 @@
   virtual ~QuicConnectionHelper();
 
   // QuicConnectionHelperInterface
-  virtual const QuicClock* GetClock() const OVERRIDE;
-  virtual QuicRandom* GetRandomGenerator() OVERRIDE;
-  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE;
+  virtual const QuicClock* GetClock() const override;
+  virtual QuicRandom* GetRandomGenerator() override;
+  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
 
  private:
   base::TaskRunner* task_runner_;
diff --git a/net/quic/quic_connection_helper_test.cc b/net/quic/quic_connection_helper_test.cc
index 638ca46..8a2c931 100644
--- a/net/quic/quic_connection_helper_test.cc
+++ b/net/quic/quic_connection_helper_test.cc
@@ -17,7 +17,7 @@
  public:
   TestDelegate() : fired_(false) {}
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     fired_ = true;
     return QuicTime::Zero();
   }
diff --git a/net/quic/quic_connection_logger.cc b/net/quic/quic_connection_logger.cc
index 4e40417..b5ca18b 100644
--- a/net/quic/quic_connection_logger.cc
+++ b/net/quic/quic_connection_logger.cc
@@ -46,24 +46,22 @@
 }
 
 base::Value* NetLogQuicPacketSentCallback(
-    QuicPacketSequenceNumber sequence_number,
+    const SerializedPacket& serialized_packet,
     QuicPacketSequenceNumber original_sequence_number,
     EncryptionLevel level,
     TransmissionType transmission_type,
     size_t packet_size,
-    WriteResult result,
+    QuicTime sent_time,
     NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetInteger("encryption_level", level);
   dict->SetInteger("transmission_type", transmission_type);
   dict->SetString("packet_sequence_number",
-                  base::Uint64ToString(sequence_number));
+                  base::Uint64ToString(serialized_packet.sequence_number));
   dict->SetString("original_sequence_number",
                   base::Uint64ToString(original_sequence_number));
   dict->SetInteger("size", packet_size);
-  if (result.status != WRITE_STATUS_OK) {
-    dict->SetInteger("net_error", result.error_code);
-  }
+  dict->SetInteger("sent_time_us", sent_time.ToDebuggingValue());
   return dict;
 }
 
@@ -324,8 +322,10 @@
 
 }  // namespace
 
-QuicConnectionLogger::QuicConnectionLogger(const BoundNetLog& net_log)
+QuicConnectionLogger::QuicConnectionLogger(QuicSession* session,
+                                           const BoundNetLog& net_log)
     : net_log_(net_log),
+      session_(session),
       last_received_packet_sequence_number_(0),
       last_received_packet_size_(0),
       largest_received_packet_sequence_number_(0),
@@ -454,6 +454,10 @@
                      frame.stop_waiting_frame));
       break;
     case PING_FRAME:
+      UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ConnectionFlowControlBlocked",
+                            session_->IsConnectionFlowControlBlocked());
+      UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.StreamFlowControlBlocked",
+                            session_->IsStreamFlowControlBlocked());
       // PingFrame has no contents to log, so just record that it was sent.
       net_log_.AddEvent(NetLog::TYPE_QUIC_SESSION_PING_FRAME_SENT);
       break;
@@ -463,17 +467,17 @@
 }
 
 void QuicConnectionLogger::OnPacketSent(
-    QuicPacketSequenceNumber sequence_number,
+    const SerializedPacket& serialized_packet,
     QuicPacketSequenceNumber original_sequence_number,
     EncryptionLevel level,
     TransmissionType transmission_type,
     const QuicEncryptedPacket& packet,
-    WriteResult result) {
+    QuicTime sent_time) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_PACKET_SENT,
-      base::Bind(&NetLogQuicPacketSentCallback, sequence_number,
+      base::Bind(&NetLogQuicPacketSentCallback, serialized_packet,
                  original_sequence_number, level, transmission_type,
-                 packet.length(), result));
+                 packet.length(), sent_time));
 }
 
 void QuicConnectionLogger::OnPacketReceived(const IPEndPoint& self_address,
diff --git a/net/quic/quic_connection_logger.h b/net/quic/quic_connection_logger.h
index 7693d79..c714e3b 100644
--- a/net/quic/quic_connection_logger.h
+++ b/net/quic/quic_connection_logger.h
@@ -12,6 +12,7 @@
 #include "net/base/network_change_notifier.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/quic_session.h"
 
 namespace net {
 namespace test {
@@ -26,51 +27,51 @@
 class NET_EXPORT_PRIVATE QuicConnectionLogger
     : public QuicConnectionDebugVisitor {
  public:
-  explicit QuicConnectionLogger(const BoundNetLog& net_log);
+  QuicConnectionLogger(QuicSession* session, const BoundNetLog& net_log);
 
   virtual ~QuicConnectionLogger();
 
   // QuicPacketGenerator::DebugDelegateInterface
-  virtual void OnFrameAddedToPacket(const QuicFrame& frame) OVERRIDE;
+  virtual void OnFrameAddedToPacket(const QuicFrame& frame) override;
 
   // QuicConnectionDebugVisitorInterface
-  virtual void OnPacketSent(QuicPacketSequenceNumber sequence_number,
+  virtual void OnPacketSent(const SerializedPacket& serialized_packet,
                             QuicPacketSequenceNumber original_sequence_number,
                             EncryptionLevel level,
                             TransmissionType transmission_type,
                             const QuicEncryptedPacket& packet,
-                            WriteResult result) OVERRIDE;
+                            QuicTime sent_time) override;
   virtual void OnPacketReceived(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address,
-                                const QuicEncryptedPacket& packet) OVERRIDE;
+                                const QuicEncryptedPacket& packet) override;
   virtual void OnIncorrectConnectionId(
-      QuicConnectionId connection_id) OVERRIDE;
-  virtual void OnUndecryptablePacket() OVERRIDE;
+      QuicConnectionId connection_id) override;
+  virtual void OnUndecryptablePacket() override;
   virtual void OnDuplicatePacket(QuicPacketSequenceNumber sequence_number)
-      OVERRIDE;
-  virtual void OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
-  virtual void OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
-  virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
+      override;
+  virtual void OnProtocolVersionMismatch(QuicVersion version) override;
+  virtual void OnPacketHeader(const QuicPacketHeader& header) override;
+  virtual void OnStreamFrame(const QuicStreamFrame& frame) override;
+  virtual void OnAckFrame(const QuicAckFrame& frame) override;
   virtual void OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE;
-  virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE;
-  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
+      const QuicCongestionFeedbackFrame& frame) override;
+  virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
+  virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
   virtual void OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) OVERRIDE;
-  virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) OVERRIDE;
-  virtual void OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE;
-  virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
-  virtual void OnPingFrame(const QuicPingFrame& frame) OVERRIDE;
+      const QuicConnectionCloseFrame& frame) override;
+  virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+  virtual void OnBlockedFrame(const QuicBlockedFrame& frame) override;
+  virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
+  virtual void OnPingFrame(const QuicPingFrame& frame) override;
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE;
+      const QuicPublicResetPacket& packet) override;
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE;
+      const QuicVersionNegotiationPacket& packet) override;
   virtual void OnRevivedPacket(const QuicPacketHeader& revived_header,
-                               base::StringPiece payload) OVERRIDE;
-  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
+                               base::StringPiece payload) override;
+  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
   virtual void OnSuccessfulVersionNegotiation(
-      const QuicVersion& version) OVERRIDE;
+      const QuicVersion& version) override;
 
   void OnCryptoHandshakeMessageReceived(
       const CryptoHandshakeMessage& message);
@@ -119,6 +120,7 @@
   void RecordLossHistograms() const;
 
   BoundNetLog net_log_;
+  QuicSession* session_;  // Unowned.
   // The last packet sequence number received.
   QuicPacketSequenceNumber last_received_packet_sequence_number_;
   // The size of the most recently received packet.
diff --git a/net/quic/quic_connection_logger_unittest.cc b/net/quic/quic_connection_logger_unittest.cc
index 9f9cd9a..dbba7d7 100644
--- a/net/quic/quic_connection_logger_unittest.cc
+++ b/net/quic/quic_connection_logger_unittest.cc
@@ -19,7 +19,7 @@
 
 class QuicConnectionLoggerTest : public ::testing::Test {
  protected:
-  QuicConnectionLoggerTest() : logger_(net_log_) {}
+  QuicConnectionLoggerTest() : logger_(nullptr, net_log_) {}
 
   BoundNetLog net_log_;
   QuicConnectionLogger logger_;
diff --git a/net/quic/quic_connection_stats.h b/net/quic/quic_connection_stats.h
index 1cb8ca7..c681dea 100644
--- a/net/quic/quic_connection_stats.h
+++ b/net/quic/quic_connection_stats.h
@@ -51,8 +51,8 @@
   uint32 rto_count;  // Count of times the rto timer fired.
   uint32 spurious_rto_count;
 
-  uint32 min_rtt_us;  // Minimum RTT in microseconds.
-  uint32 srtt_us;  // Smoothed RTT in microseconds.
+  int64 min_rtt_us;  // Minimum RTT in microseconds.
+  int64 srtt_us;  // Smoothed RTT in microseconds.
   uint32 max_packet_size;  // In bytes.
   uint64 estimated_bandwidth;  // In bytes per second.
   uint32 congestion_window;  // In bytes
@@ -64,7 +64,7 @@
   // Maximum reordering observed in sequence space.
   uint32 max_sequence_reordering;
   // Maximum reordering observed in microseconds
-  uint32 max_time_reordering_us;
+  int64 max_time_reordering_us;
 
   // The following stats are used only in TcpCubicSender.
   // The number of loss events from TCP's perspective.  Each loss event includes
diff --git a/net/quic/quic_connection_test.cc b/net/quic/quic_connection_test.cc
index 2869513..b084428 100644
--- a/net/quic/quic_connection_test.cc
+++ b/net/quic/quic_connection_test.cc
@@ -93,15 +93,15 @@
   virtual ~TaggingEncrypter() {}
 
   // QuicEncrypter interface.
-  virtual bool SetKey(StringPiece key) OVERRIDE { return true; }
-  virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+  virtual bool SetKey(StringPiece key) override { return true; }
+  virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
     return true;
   }
 
   virtual bool Encrypt(StringPiece nonce,
                        StringPiece associated_data,
                        StringPiece plaintext,
-                       unsigned char* output) OVERRIDE {
+                       unsigned char* output) override {
     memcpy(output, plaintext.data(), plaintext.size());
     output += plaintext.size();
     memset(output, tag_, kTagSize);
@@ -110,29 +110,29 @@
 
   virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
                                   StringPiece associated_data,
-                                  StringPiece plaintext) OVERRIDE {
+                                  StringPiece plaintext) override {
     const size_t len = plaintext.size() + kTagSize;
     uint8* buffer = new uint8[len];
     Encrypt(StringPiece(), associated_data, plaintext, buffer);
     return new QuicData(reinterpret_cast<char*>(buffer), len, true);
   }
 
-  virtual size_t GetKeySize() const OVERRIDE { return 0; }
-  virtual size_t GetNoncePrefixSize() const OVERRIDE { return 0; }
+  virtual size_t GetKeySize() const override { return 0; }
+  virtual size_t GetNoncePrefixSize() const override { return 0; }
 
-  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE {
+  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
     return ciphertext_size - kTagSize;
   }
 
-  virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE {
+  virtual size_t GetCiphertextSize(size_t plaintext_size) const override {
     return plaintext_size + kTagSize;
   }
 
-  virtual StringPiece GetKey() const OVERRIDE {
+  virtual StringPiece GetKey() const override {
     return StringPiece();
   }
 
-  virtual StringPiece GetNoncePrefix() const OVERRIDE {
+  virtual StringPiece GetNoncePrefix() const override {
     return StringPiece();
   }
 
@@ -153,8 +153,8 @@
   virtual ~TaggingDecrypter() {}
 
   // QuicDecrypter interface
-  virtual bool SetKey(StringPiece key) OVERRIDE { return true; }
-  virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+  virtual bool SetKey(StringPiece key) override { return true; }
+  virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
     return true;
   }
 
@@ -162,7 +162,7 @@
                        StringPiece associated_data,
                        StringPiece ciphertext,
                        unsigned char* output,
-                       size_t* output_length) OVERRIDE {
+                       size_t* output_length) override {
     if (ciphertext.size() < kTagSize) {
       return false;
     }
@@ -176,7 +176,7 @@
 
   virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
                                   StringPiece associated_data,
-                                  StringPiece ciphertext) OVERRIDE {
+                                  StringPiece ciphertext) override {
     if (ciphertext.size() < kTagSize) {
       return nullptr;
     }
@@ -190,8 +190,8 @@
                         true /* owns buffer */);
   }
 
-  virtual StringPiece GetKey() const OVERRIDE { return StringPiece(); }
-  virtual StringPiece GetNoncePrefix() const OVERRIDE { return StringPiece(); }
+  virtual StringPiece GetKey() const override { return StringPiece(); }
+  virtual StringPiece GetNoncePrefix() const override { return StringPiece(); }
 
  protected:
   virtual uint8 GetTag(StringPiece ciphertext) {
@@ -222,7 +222,7 @@
   virtual ~StrictTaggingDecrypter() {}
 
   // TaggingQuicDecrypter
-  virtual uint8 GetTag(StringPiece ciphertext) OVERRIDE {
+  virtual uint8 GetTag(StringPiece ciphertext) override {
     return tag_;
   }
 
@@ -238,8 +238,8 @@
         : QuicAlarm(delegate) {
     }
 
-    virtual void SetImpl() OVERRIDE {}
-    virtual void CancelImpl() OVERRIDE {}
+    virtual void SetImpl() override {}
+    virtual void CancelImpl() override {}
     using QuicAlarm::Fire;
   };
 
@@ -250,15 +250,15 @@
   }
 
   // QuicConnectionHelperInterface
-  virtual const QuicClock* GetClock() const OVERRIDE {
+  virtual const QuicClock* GetClock() const override {
     return clock_;
   }
 
-  virtual QuicRandom* GetRandomGenerator() OVERRIDE {
+  virtual QuicRandom* GetRandomGenerator() override {
     return random_generator_;
   }
 
-  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE {
+  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override {
     return new TestAlarm(delegate);
   }
 
@@ -288,7 +288,7 @@
   virtual WriteResult WritePacket(
       const char* buffer, size_t buf_len,
       const IPAddressNumber& self_address,
-      const IPEndPoint& peer_address) OVERRIDE {
+      const IPEndPoint& peer_address) override {
     QuicEncryptedPacket packet(buffer, buf_len);
     ++packets_write_attempts_;
 
@@ -313,13 +313,13 @@
     return WriteResult(WRITE_STATUS_OK, last_packet_size_);
   }
 
-  virtual bool IsWriteBlockedDataBuffered() const OVERRIDE {
+  virtual bool IsWriteBlockedDataBuffered() const override {
     return is_write_blocked_data_buffered_;
   }
 
-  virtual bool IsWriteBlocked() const OVERRIDE { return write_blocked_; }
+  virtual bool IsWriteBlocked() const override { return write_blocked_; }
 
-  virtual void SetWritable() OVERRIDE { write_blocked_ = false; }
+  virtual void SetWritable() override { write_blocked_ = false; }
 
   void BlockOnNextWrite() { block_on_next_write_ = true; }
 
@@ -591,7 +591,7 @@
     : public QuicConnectionDebugVisitor {
  public:
   virtual void OnRevivedPacket(const QuicPacketHeader& header,
-                               StringPiece data) OVERRIDE {
+                               StringPiece data) override {
     revived_header_ = header;
   }
 
@@ -2416,19 +2416,22 @@
 }
 
 TEST_P(QuicConnectionTest, BufferNonDecryptablePackets) {
+  // SetFromConfig is always called after construction from InitializeSession.
+  EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+  QuicConfig config;
+  connection_.SetFromConfig(config);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   use_tagging_decrypter();
 
   const uint8 tag = 0x07;
   framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
 
-  // Process an encrypted packet which can not yet be decrypted
-  // which should result in the packet being buffered.
+  // Process an encrypted packet which can not yet be decrypted which should
+  // result in the packet being buffered.
   ProcessDataPacketAtLevel(1, 0, kEntropyFlag, ENCRYPTION_INITIAL);
 
-  // Transition to the new encryption state and process another
-  // encrypted packet which should result in the original packet being
-  // processed.
+  // Transition to the new encryption state and process another encrypted packet
+  // which should result in the original packet being processed.
   connection_.SetDecrypter(new StrictTaggingDecrypter(tag),
                            ENCRYPTION_INITIAL);
   connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
@@ -2436,12 +2439,44 @@
   EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(2);
   ProcessDataPacketAtLevel(2, 0, kEntropyFlag, ENCRYPTION_INITIAL);
 
-  // Finally, process a third packet and note that we do not
-  // reprocess the buffered packet.
+  // Finally, process a third packet and note that we do not reprocess the
+  // buffered packet.
   EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(1);
   ProcessDataPacketAtLevel(3, 0, kEntropyFlag, ENCRYPTION_INITIAL);
 }
 
+TEST_P(QuicConnectionTest, Buffer100NonDecryptablePackets) {
+  // SetFromConfig is always called after construction from InitializeSession.
+  EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
+  QuicConfig config;
+  config.set_max_undecryptable_packets(100);
+  connection_.SetFromConfig(config);
+  EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
+  use_tagging_decrypter();
+
+  const uint8 tag = 0x07;
+  framer_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
+
+  // Process an encrypted packet which can not yet be decrypted which should
+  // result in the packet being buffered.
+  for (QuicPacketSequenceNumber i = 1; i <= 100; ++i) {
+    ProcessDataPacketAtLevel(i, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+  }
+
+  // Transition to the new encryption state and process another encrypted packet
+  // which should result in the original packets being processed.
+  connection_.SetDecrypter(new StrictTaggingDecrypter(tag), ENCRYPTION_INITIAL);
+  connection_.SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
+  connection_.SetEncrypter(ENCRYPTION_INITIAL, new TaggingEncrypter(tag));
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(101);
+  ProcessDataPacketAtLevel(101, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+
+  // Finally, process a third packet and note that we do not reprocess the
+  // buffered packet.
+  EXPECT_CALL(visitor_, OnStreamFrames(_)).Times(1);
+  ProcessDataPacketAtLevel(102, 0, kEntropyFlag, ENCRYPTION_INITIAL);
+}
+
 TEST_P(QuicConnectionTest, TestRetransmitOrder) {
   QuicByteCount first_packet_size;
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).WillOnce(
@@ -2682,7 +2717,6 @@
   // SetFromConfig sets the initial timeouts before negotiation.
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   QuicConfig config;
-  config.SetDefaults();
   connection_.SetFromConfig(config);
   // Subtract a second from the idle timeout on the client side.
   QuicTime default_timeout = clock_.ApproximateNow().Add(
@@ -2835,7 +2869,6 @@
   EXPECT_TRUE(connection_.connected());
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   QuicConfig config;
-  config.SetDefaults();
   connection_.SetFromConfig(config);
 
   const QuicTime::Delta initial_idle_timeout =
@@ -3924,12 +3957,12 @@
                void(const QuicFrame&));
 
   MOCK_METHOD6(OnPacketSent,
-               void(QuicPacketSequenceNumber,
+               void(const SerializedPacket&,
                     QuicPacketSequenceNumber,
                     EncryptionLevel,
                     TransmissionType,
                     const QuicEncryptedPacket&,
-                    WriteResult));
+                    QuicTime));
 
   MOCK_METHOD3(OnPacketReceived,
                void(const IPEndPoint&,
diff --git a/net/quic/quic_crypto_client_stream.h b/net/quic/quic_crypto_client_stream.h
index 96d2556..801c3da 100644
--- a/net/quic/quic_crypto_client_stream.h
+++ b/net/quic/quic_crypto_client_stream.h
@@ -33,7 +33,7 @@
 
   // CryptoFramerVisitorInterface implementation
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE;
+      const CryptoHandshakeMessage& message) override;
 
   // Performs a crypto handshake with the server. Returns true if the crypto
   // handshake is started successfully.
@@ -62,7 +62,7 @@
     virtual ~ChannelIDSourceCallbackImpl();
 
     // ChannelIDSourceCallback interface.
-    virtual void Run(scoped_ptr<ChannelIDKey>* channel_id_key) OVERRIDE;
+    virtual void Run(scoped_ptr<ChannelIDKey>* channel_id_key) override;
 
     // Cancel causes any future callbacks to be ignored. It must be called on
     // the same thread as the callback will be made on.
@@ -83,7 +83,7 @@
     // ProofVerifierCallback interface.
     virtual void Run(bool ok,
                      const string& error_details,
-                     scoped_ptr<ProofVerifyDetails>* details) OVERRIDE;
+                     scoped_ptr<ProofVerifyDetails>* details) override;
 
     // Cancel causes any future callbacks to be ignored. It must be called on
     // the same thread as the callback will be made on.
diff --git a/net/quic/quic_crypto_client_stream_test.cc b/net/quic/quic_crypto_client_stream_test.cc
index 5a8b08c..1df2313 100644
--- a/net/quic/quic_crypto_client_stream_test.cc
+++ b/net/quic/quic_crypto_client_stream_test.cc
@@ -34,8 +34,6 @@
         stream_(new QuicCryptoClientStream(server_id_, session_.get(), nullptr,
                                            &crypto_config_)) {
     session_->SetCryptoStream(stream_.get());
-    session_->config()->SetDefaults();
-    crypto_config_.SetDefaults();
   }
 
   void CompleteCryptoHandshake() {
@@ -127,7 +125,6 @@
                                            &crypto_config_));
 
   session_->SetCryptoStream(stream_.get());
-  session_->config()->SetDefaults();
 
   // Advance time 5 years to ensure that we pass the expiry time of the cached
   // server config.
diff --git a/net/quic/quic_crypto_server_stream.cc b/net/quic/quic_crypto_server_stream.cc
index eebab90..e912c32 100644
--- a/net/quic/quic_crypto_server_stream.cc
+++ b/net/quic/quic_crypto_server_stream.cc
@@ -11,6 +11,7 @@
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/source_address_token.h"
 #include "net/quic/quic_config.h"
+#include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_session.h"
 
@@ -152,11 +153,12 @@
 
   // Now that the handshake is complete, send an updated server config and
   // source-address token to the client.
-  SendServerConfigUpdate(nullptr);
+  SendServerConfigUpdate(previous_cached_network_params_.get(), true);
 }
 
 void QuicCryptoServerStream::SendServerConfigUpdate(
-    const CachedNetworkParameters* cached_network_params) {
+    const CachedNetworkParameters* cached_network_params,
+    bool on_handshake_complete) {
   if (session()->connection()->version() <= QUIC_VERSION_21 ||
       !handshake_confirmed_) {
     return;
@@ -174,7 +176,8 @@
     return;
   }
 
-  DVLOG(1) << "Server: Sending server config update: "
+  DVLOG(1) << "Server: Sending server config update"
+           << (on_handshake_complete ? " immediately after handshake: " : ": ")
            << server_config_update_message.DebugString();
   const QuicData& data = server_config_update_message.GetSerialized();
   WriteOrBufferData(string(data.data(), data.length()), false, nullptr);
@@ -221,6 +224,13 @@
     const ValidateClientHelloResultCallback::Result& result,
     CryptoHandshakeMessage* reply,
     string* error_details) {
+  // Store the bandwidth estimate from the client.
+  if (FLAGS_quic_store_cached_network_params_from_chlo &&
+      result.cached_network_params.bandwidth_estimate_bytes_per_second() > 0) {
+    previous_cached_network_params_.reset(
+        new CachedNetworkParameters(result.cached_network_params));
+  }
+
   return crypto_config_.ProcessClientHello(
       result,
       session()->connection()->connection_id(),
diff --git a/net/quic/quic_crypto_server_stream.h b/net/quic/quic_crypto_server_stream.h
index 46ac4f3..5d55564 100644
--- a/net/quic/quic_crypto_server_stream.h
+++ b/net/quic/quic_crypto_server_stream.h
@@ -38,7 +38,7 @@
       int num_original_bytes,
       int num_retransmitted_packets,
       int num_retransmitted_bytes,
-      QuicTime::Delta delta_largest_observed) OVERRIDE;
+      QuicTime::Delta delta_largest_observed) override;
 
  private:
   virtual ~ServerHelloNotifier() {}
@@ -60,7 +60,7 @@
 
   // CryptoFramerVisitorInterface implementation
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE;
+      const CryptoHandshakeMessage& message) override;
 
   // GetBase64SHA256ClientChannelID sets |*output| to the base64 encoded,
   // SHA-256 hash of the client's ChannelID key and returns true, if the client
@@ -74,8 +74,11 @@
   }
 
   // Sends the latest server config and source-address token to the client.
+  // |on_handshake_complete| is true when this is called immediately after
+  // handshake completes, and should be false for subsequent updates.
   virtual void SendServerConfigUpdate(
-      const CachedNetworkParameters* cached_network_params);
+      const CachedNetworkParameters* cached_network_params,
+      bool on_handshake_complete);
 
   // Called by the ServerHello AckNotifier once the SHLO has been ACKed by the
   // client.
@@ -103,7 +106,7 @@
 
     // From ValidateClientHelloResultCallback
     virtual void RunImpl(const CryptoHandshakeMessage& client_hello,
-                         const Result& result) OVERRIDE;
+                         const Result& result) override;
 
    private:
     QuicCryptoServerStream* parent_;
@@ -133,6 +136,11 @@
   // Number of server config update (SCUP) messages sent by this stream.
   int num_server_config_update_messages_sent_;
 
+  // If the client provides CachedNetworkParameters in the STK in the CHLO, then
+  // store here, and send back in future STKs if we have no better bandwidth
+  // estimate to send.
+  scoped_ptr<CachedNetworkParameters> previous_cached_network_params_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicCryptoServerStream);
 };
 
diff --git a/net/quic/quic_crypto_server_stream_test.cc b/net/quic/quic_crypto_server_stream_test.cc
index 6ce059b..38b4a57 100644
--- a/net/quic/quic_crypto_server_stream_test.cc
+++ b/net/quic/quic_crypto_server_stream_test.cc
@@ -61,8 +61,6 @@
                        QuicRandom::GetInstance()),
         stream_(crypto_config_, &session_),
         strike_register_client_(nullptr) {
-    config_.SetDefaults();
-    session_.config()->SetDefaults();
     session_.SetCryptoStream(&stream_);
     // We advance the clock initially because the default time is zero and the
     // strike register worries that we've just overflowed a uint32 time.
@@ -141,11 +139,9 @@
   server_conn->AdvanceTime(QuicTime::Delta::FromSeconds(100000));
 
   QuicConfig client_config;
-  client_config.SetDefaults();
   scoped_ptr<TestClientSession> client_session(
       new TestClientSession(client_conn, client_config));
   QuicCryptoClientConfig client_crypto_config;
-  client_crypto_config.SetDefaults();
 
   QuicServerId server_id(kServerHostname, kServerPort, false,
                          PRIVACY_MODE_DISABLED);
@@ -277,7 +273,7 @@
 
 TEST_P(QuicCryptoServerStreamTest, OnlySendSCUPAfterHandshakeComplete) {
   // An attempt to send a SCUP before completing handshake should fail.
-  stream_.SendServerConfigUpdate(nullptr);
+  stream_.SendServerConfigUpdate(nullptr, false);
   EXPECT_EQ(0, stream_.num_server_config_update_messages_sent());
 }
 
diff --git a/net/quic/quic_crypto_stream.h b/net/quic/quic_crypto_stream.h
index dc8b227..6698e3e 100644
--- a/net/quic/quic_crypto_stream.h
+++ b/net/quic/quic_crypto_stream.h
@@ -34,13 +34,13 @@
   explicit QuicCryptoStream(QuicSession* session);
 
   // CryptoFramerVisitorInterface implementation
-  virtual void OnError(CryptoFramer* framer) OVERRIDE;
+  virtual void OnError(CryptoFramer* framer) override;
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE;
+      const CryptoHandshakeMessage& message) override;
 
   // ReliableQuicStream implementation
-  virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE;
-  virtual QuicPriority EffectivePriority() const OVERRIDE;
+  virtual uint32 ProcessRawData(const char* data, uint32 data_len) override;
+  virtual QuicPriority EffectivePriority() const override;
 
   // Sends |message| to the peer.
   // TODO(wtc): return a success/failure status.
diff --git a/net/quic/quic_crypto_stream_test.cc b/net/quic/quic_crypto_stream_test.cc
index 4ea8f49..e79a1f3 100644
--- a/net/quic/quic_crypto_stream_test.cc
+++ b/net/quic/quic_crypto_stream_test.cc
@@ -30,7 +30,7 @@
   }
 
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE {
+      const CryptoHandshakeMessage& message) override {
     messages_.push_back(message);
   }
 
diff --git a/net/quic/quic_data_stream.h b/net/quic/quic_data_stream.h
index 1af9004..7cb9816 100644
--- a/net/quic/quic_data_stream.h
+++ b/net/quic/quic_data_stream.h
@@ -57,13 +57,13 @@
   virtual ~QuicDataStream();
 
   // ReliableQuicStream implementation
-  virtual void OnClose() OVERRIDE;
-  virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE;
+  virtual void OnClose() override;
+  virtual uint32 ProcessRawData(const char* data, uint32 data_len) override;
   // By default, this is the same as priority(), however it allows streams
   // to temporarily alter effective priority.   For example if a SPDY stream has
   // compressed but not written headers it can write the headers with a higher
   // priority.
-  virtual QuicPriority EffectivePriority() const OVERRIDE;
+  virtual QuicPriority EffectivePriority() const override;
 
   // Overridden by subclasses to process data.  The headers will be delivered
   // via OnStreamHeaders, so only data will be delivered through this method.
diff --git a/net/quic/quic_data_stream_test.cc b/net/quic/quic_data_stream_test.cc
index 279dcd3..2f6d84e 100644
--- a/net/quic/quic_data_stream_test.cc
+++ b/net/quic/quic_data_stream_test.cc
@@ -40,7 +40,7 @@
       : QuicDataStream(id, session),
         should_process_data_(should_process_data) {}
 
-  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
+  virtual uint32 ProcessData(const char* data, uint32 data_len) override {
     EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
diff --git a/net/quic/quic_default_packet_writer.h b/net/quic/quic_default_packet_writer.h
index 15eb0dd..329f7cc 100644
--- a/net/quic/quic_default_packet_writer.h
+++ b/net/quic/quic_default_packet_writer.h
@@ -29,10 +29,10 @@
   virtual WriteResult WritePacket(const char* buffer,
                                   size_t buf_len,
                                   const IPAddressNumber& self_address,
-                                  const IPEndPoint& peer_address) OVERRIDE;
-  virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
-  virtual bool IsWriteBlocked() const OVERRIDE;
-  virtual void SetWritable() OVERRIDE;
+                                  const IPEndPoint& peer_address) override;
+  virtual bool IsWriteBlockedDataBuffered() const override;
+  virtual bool IsWriteBlocked() const override;
+  virtual void SetWritable() override;
 
   void OnWriteComplete(int rv);
   void SetConnection(QuicConnection* connection) {
diff --git a/net/quic/quic_dispatcher.cc b/net/quic/quic_dispatcher.cc
index a72faa6..121e32f 100644
--- a/net/quic/quic_dispatcher.cc
+++ b/net/quic/quic_dispatcher.cc
@@ -28,7 +28,7 @@
       : dispatcher_(dispatcher) {
   }
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     dispatcher_->DeleteSessions();
     return QuicTime::Zero();
   }
@@ -44,23 +44,23 @@
         connection_id_(0) {}
 
   // QuicFramerVisitorInterface implementation
-  virtual void OnPacket() OVERRIDE {}
+  virtual void OnPacket() override {}
   virtual bool OnUnauthenticatedPublicHeader(
-      const QuicPacketPublicHeader& header) OVERRIDE {
+      const QuicPacketPublicHeader& header) override {
     connection_id_ = header.connection_id;
     return dispatcher_->OnUnauthenticatedPublicHeader(header);
   }
   virtual bool OnUnauthenticatedHeader(
-      const QuicPacketHeader& header) OVERRIDE {
+      const QuicPacketHeader& header) override {
     dispatcher_->OnUnauthenticatedHeader(header);
     return false;
   }
-  virtual void OnError(QuicFramer* framer) OVERRIDE {
+  virtual void OnError(QuicFramer* framer) override {
     DVLOG(1) << QuicUtils::ErrorToString(framer->error());
   }
 
   virtual bool OnProtocolVersionMismatch(
-      QuicVersion /*received_version*/) OVERRIDE {
+      QuicVersion /*received_version*/) override {
     if (dispatcher_->time_wait_list_manager()->IsConnectionIdInTimeWait(
             connection_id_)) {
       // Keep processing after protocol mismatch - this will be dealt with by
@@ -77,74 +77,74 @@
   // false from OnUnauthenticatedHeader().  As a result, we never process the
   // payload of the packet.
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& /*packet*/) OVERRIDE {
+      const QuicPublicResetPacket& /*packet*/) override {
     DCHECK(false);
   }
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& /*packet*/) OVERRIDE {
+      const QuicVersionNegotiationPacket& /*packet*/) override {
     DCHECK(false);
   }
-  virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {
+  virtual void OnDecryptedPacket(EncryptionLevel level) override {
     DCHECK(false);
   }
-  virtual bool OnPacketHeader(const QuicPacketHeader& /*header*/) OVERRIDE {
+  virtual bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
     DCHECK(false);
     return false;
   }
-  virtual void OnRevivedPacket() OVERRIDE {
+  virtual void OnRevivedPacket() override {
     DCHECK(false);
   }
-  virtual void OnFecProtectedPayload(StringPiece /*payload*/) OVERRIDE {
+  virtual void OnFecProtectedPayload(StringPiece /*payload*/) override {
     DCHECK(false);
   }
-  virtual bool OnStreamFrame(const QuicStreamFrame& /*frame*/) OVERRIDE {
+  virtual bool OnStreamFrame(const QuicStreamFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnAckFrame(const QuicAckFrame& /*frame*/) OVERRIDE {
+  virtual bool OnAckFrame(const QuicAckFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
   virtual bool OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& /*frame*/) OVERRIDE {
+      const QuicCongestionFeedbackFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
   virtual bool OnStopWaitingFrame(
-      const QuicStopWaitingFrame& /*frame*/) OVERRIDE {
+      const QuicStopWaitingFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnPingFrame(const QuicPingFrame& /*frame*/) OVERRIDE {
+  virtual bool OnPingFrame(const QuicPingFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) OVERRIDE {
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
   virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame & /*frame*/) OVERRIDE {
+      const QuicConnectionCloseFrame & /*frame*/) override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) OVERRIDE {
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
   virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/)
-      OVERRIDE {
+      override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
+  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
     DCHECK(false);
     return false;
   }
-  virtual void OnFecData(const QuicFecData& /*fec*/) OVERRIDE {
+  virtual void OnFecData(const QuicFecData& /*fec*/) override {
     DCHECK(false);
   }
-  virtual void OnPacketComplete() OVERRIDE {
+  virtual void OnPacketComplete() override {
     DCHECK(false);
   }
 
diff --git a/net/quic/quic_dispatcher.h b/net/quic/quic_dispatcher.h
index d07c46c..b4be0ee 100644
--- a/net/quic/quic_dispatcher.h
+++ b/net/quic/quic_dispatcher.h
@@ -64,7 +64,7 @@
 
     virtual QuicPacketWriter* Create(
         QuicServerPacketWriter* writer,
-        QuicConnection* connection) OVERRIDE;
+        QuicConnection* connection) override;
   };
 
   // Ideally we'd have a linked_hash_set: the  boolean is unused.
@@ -89,7 +89,7 @@
   // an existing session, or passing it to the TimeWaitListManager.
   virtual void ProcessPacket(const IPEndPoint& server_address,
                              const IPEndPoint& client_address,
-                             const QuicEncryptedPacket& packet) OVERRIDE;
+                             const QuicEncryptedPacket& packet) override;
 
   // Returns true if there's anything in the blocked writer list.
   virtual bool HasPendingWrites() const;
@@ -99,16 +99,16 @@
 
   // QuicBlockedWriterInterface implementation:
   // Called when the socket becomes writable to allow queued writes to happen.
-  virtual void OnCanWrite() OVERRIDE;
+  virtual void OnCanWrite() override;
 
   // QuicServerSessionVisitor interface implementation:
   // Ensure that the closed connection is cleaned up asynchronously.
   virtual void OnConnectionClosed(QuicConnectionId connection_id,
-                                  QuicErrorCode error) OVERRIDE;
+                                  QuicErrorCode error) override;
 
   // Queues the blocked writer for later resumption.
   virtual void OnWriteBlocked(
-      QuicBlockedWriterInterface* blocked_writer) OVERRIDE;
+      QuicBlockedWriterInterface* blocked_writer) override;
 
   typedef base::hash_map<QuicConnectionId, QuicSession*> SessionMap;
 
@@ -185,7 +185,7 @@
     PacketWriterFactoryAdapter(QuicDispatcher* dispatcher);
     virtual ~PacketWriterFactoryAdapter ();
 
-    virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE;
+    virtual QuicPacketWriter* Create(QuicConnection* connection) const override;
 
    private:
     QuicDispatcher* dispatcher_;
diff --git a/net/quic/quic_end_to_end_unittest.cc b/net/quic/quic_end_to_end_unittest.cc
index a37bd19..b589bc6 100644
--- a/net/quic/quic_end_to_end_unittest.cc
+++ b/net/quic/quic_end_to_end_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
@@ -53,16 +54,16 @@
 
   // HttpTransactionFactory methods
   virtual int CreateTransaction(RequestPriority priority,
-                                scoped_ptr<HttpTransaction>* trans) OVERRIDE {
+                                scoped_ptr<HttpTransaction>* trans) override {
     trans->reset(new HttpNetworkTransaction(priority, session_.get()));
     return OK;
   }
 
-  virtual HttpCache* GetCache() OVERRIDE {
+  virtual HttpCache* GetCache() override {
     return nullptr;
   }
 
-  virtual HttpNetworkSession* GetSession() OVERRIDE { return session_.get(); };
+  virtual HttpNetworkSession* GetSession() override { return session_.get(); };
 
  private:
   scoped_refptr<HttpNetworkSession> session_;
@@ -132,7 +133,6 @@
     net::IPAddressNumber ip;
     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
     server_address_ = IPEndPoint(ip, 0);
-    server_config_.SetDefaults();
     server_config_.SetInitialFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
     server_config_.SetInitialStreamFlowControlWindowToSend(
@@ -189,7 +189,8 @@
     element_readers.push_back(
         new UploadBytesElementReader(request_body_.data(),
                                      request_body_.length()));
-    upload_data_stream_.reset(new UploadDataStream(element_readers.Pass(), 0));
+    upload_data_stream_.reset(
+        new ElementsUploadDataStream(element_readers.Pass(), 0));
     request_.method = "POST";
     request_.url = GURL("http://www.google.com/");
     request_.upload_data_stream = upload_data_stream_.get();
diff --git a/net/quic/quic_flags.cc b/net/quic/quic_flags.cc
index 864e12b..9a49a34 100644
--- a/net/quic/quic_flags.cc
+++ b/net/quic/quic_flags.cc
@@ -46,3 +46,7 @@
 // If true, then QUIC connections will set both idle and overall timeouts in a
 // single method.
 bool FLAGS_quic_unified_timeouts = false;
+
+// If true, store any CachedNetworkParams that are provided in the STK from the
+// CHLO.
+bool FLAGS_quic_store_cached_network_params_from_chlo = false;
diff --git a/net/quic/quic_flags.h b/net/quic/quic_flags.h
index f1fea1e..7693260 100644
--- a/net/quic/quic_flags.h
+++ b/net/quic/quic_flags.h
@@ -18,5 +18,6 @@
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_allow_more_open_streams;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_timeouts_only_from_alarms;
 NET_EXPORT_PRIVATE extern bool FLAGS_quic_unified_timeouts;
+NET_EXPORT_PRIVATE extern bool FLAGS_quic_store_cached_network_params_from_chlo;
 
 #endif  // NET_QUIC_QUIC_FLAGS_H_
diff --git a/net/quic/quic_flow_controller.cc b/net/quic/quic_flow_controller.cc
index b145280..722b243 100644
--- a/net/quic/quic_flow_controller.cc
+++ b/net/quic/quic_flow_controller.cc
@@ -163,10 +163,12 @@
 
   DVLOG(1) << ENDPOINT << "UpdateSendWindowOffset for stream " << id_
            << " with new offset " << new_send_window_offset
-           << " , current offset: " << send_window_offset_;
+           << " current offset: " << send_window_offset_
+           << " bytes_sent: " << bytes_sent_;
 
+  const bool blocked = IsBlocked();
   send_window_offset_ = new_send_window_offset;
-  return true;
+  return blocked;
 }
 
 void QuicFlowController::Disable() {
diff --git a/net/quic/quic_flow_controller.h b/net/quic/quic_flow_controller.h
index e5f5494..0df2b0e 100644
--- a/net/quic/quic_flow_controller.h
+++ b/net/quic/quic_flow_controller.h
@@ -47,8 +47,7 @@
   void AddBytesSent(uint64 bytes_sent);
 
   // Set a new send window offset.
-  // Returns true if this changes send_window_offset_, and false in the case
-  // where |new_send_window| is <= send_window_offset_.
+  // Returns true if this increases send_window_offset_ and is now blocked.
   bool UpdateSendWindowOffset(uint64 new_send_window_offset);
 
   // Returns the current available send window.
diff --git a/net/quic/quic_framer_test.cc b/net/quic/quic_framer_test.cc
index 535d31a..9ba0fd6 100644
--- a/net/quic/quic_framer_test.cc
+++ b/net/quic/quic_framer_test.cc
@@ -104,43 +104,43 @@
 class TestEncrypter : public QuicEncrypter {
  public:
   virtual ~TestEncrypter() {}
-  virtual bool SetKey(StringPiece key) OVERRIDE {
+  virtual bool SetKey(StringPiece key) override {
     return true;
   }
-  virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+  virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
     return true;
   }
   virtual bool Encrypt(StringPiece nonce,
                        StringPiece associated_data,
                        StringPiece plaintext,
-                       unsigned char* output) OVERRIDE {
+                       unsigned char* output) override {
     CHECK(false) << "Not implemented";
     return false;
   }
   virtual QuicData* EncryptPacket(QuicPacketSequenceNumber sequence_number,
                                   StringPiece associated_data,
-                                  StringPiece plaintext) OVERRIDE {
+                                  StringPiece plaintext) override {
     sequence_number_ = sequence_number;
     associated_data_ = associated_data.as_string();
     plaintext_ = plaintext.as_string();
     return new QuicData(plaintext.data(), plaintext.length());
   }
-  virtual size_t GetKeySize() const OVERRIDE {
+  virtual size_t GetKeySize() const override {
     return 0;
   }
-  virtual size_t GetNoncePrefixSize() const OVERRIDE {
+  virtual size_t GetNoncePrefixSize() const override {
     return 0;
   }
-  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const OVERRIDE {
+  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
     return ciphertext_size;
   }
-  virtual size_t GetCiphertextSize(size_t plaintext_size) const OVERRIDE {
+  virtual size_t GetCiphertextSize(size_t plaintext_size) const override {
     return plaintext_size;
   }
-  virtual StringPiece GetKey() const OVERRIDE {
+  virtual StringPiece GetKey() const override {
     return StringPiece();
   }
-  virtual StringPiece GetNoncePrefix() const OVERRIDE {
+  virtual StringPiece GetNoncePrefix() const override {
     return StringPiece();
   }
   QuicPacketSequenceNumber sequence_number_;
@@ -151,32 +151,32 @@
 class TestDecrypter : public QuicDecrypter {
  public:
   virtual ~TestDecrypter() {}
-  virtual bool SetKey(StringPiece key) OVERRIDE {
+  virtual bool SetKey(StringPiece key) override {
     return true;
   }
-  virtual bool SetNoncePrefix(StringPiece nonce_prefix) OVERRIDE {
+  virtual bool SetNoncePrefix(StringPiece nonce_prefix) override {
     return true;
   }
   virtual bool Decrypt(StringPiece nonce,
                        StringPiece associated_data,
                        StringPiece ciphertext,
                        unsigned char* output,
-                       size_t* output_length) OVERRIDE {
+                       size_t* output_length) override {
     CHECK(false) << "Not implemented";
     return false;
   }
   virtual QuicData* DecryptPacket(QuicPacketSequenceNumber sequence_number,
                                   StringPiece associated_data,
-                                  StringPiece ciphertext) OVERRIDE {
+                                  StringPiece ciphertext) override {
     sequence_number_ = sequence_number;
     associated_data_ = associated_data.as_string();
     ciphertext_ = ciphertext.as_string();
     return new QuicData(ciphertext.data(), ciphertext.length());
   }
-  virtual StringPiece GetKey() const OVERRIDE {
+  virtual StringPiece GetKey() const override {
     return StringPiece();
   }
-  virtual StringPiece GetNoncePrefix() const OVERRIDE {
+  virtual StringPiece GetNoncePrefix() const override {
     return StringPiece();
   }
   QuicPacketSequenceNumber sequence_number_;
@@ -207,121 +207,121 @@
     STLDeleteElements(&fec_data_);
   }
 
-  virtual void OnError(QuicFramer* f) OVERRIDE {
+  virtual void OnError(QuicFramer* f) override {
     DVLOG(1) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
              << " (" << f->error() << ")";
     ++error_count_;
   }
 
-  virtual void OnPacket() OVERRIDE {}
+  virtual void OnPacket() override {}
 
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE {
+      const QuicPublicResetPacket& packet) override {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
 
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE {
+      const QuicVersionNegotiationPacket& packet) override {
     version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
   }
 
-  virtual void OnRevivedPacket() OVERRIDE {
+  virtual void OnRevivedPacket() override {
     ++revived_packets_;
   }
 
-  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) override {
     DVLOG(1) << "QuicFramer Version Mismatch, version: " << version;
     ++version_mismatch_;
     return true;
   }
 
   virtual bool OnUnauthenticatedPublicHeader(
-      const QuicPacketPublicHeader& header) OVERRIDE {
+      const QuicPacketPublicHeader& header) override {
     public_header_.reset(new QuicPacketPublicHeader(header));
     return accept_public_header_;
   }
 
   virtual bool OnUnauthenticatedHeader(
-      const QuicPacketHeader& header) OVERRIDE {
+      const QuicPacketHeader& header) override {
     return true;
   }
 
-  virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {}
+  virtual void OnDecryptedPacket(EncryptionLevel level) override {}
 
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
+  virtual bool OnPacketHeader(const QuicPacketHeader& header) override {
     ++packet_count_;
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
-  virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
+  virtual bool OnStreamFrame(const QuicStreamFrame& frame) override {
     ++frame_count_;
     stream_frames_.push_back(new QuicStreamFrame(frame));
     return true;
   }
 
-  virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {
+  virtual void OnFecProtectedPayload(StringPiece payload) override {
     fec_protected_payload_ = payload.as_string();
   }
 
-  virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
+  virtual bool OnAckFrame(const QuicAckFrame& frame) override {
     ++frame_count_;
     ack_frames_.push_back(new QuicAckFrame(frame));
     return true;
   }
 
   virtual bool OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE {
+      const QuicCongestionFeedbackFrame& frame) override {
     ++frame_count_;
     congestion_feedback_frames_.push_back(
         new QuicCongestionFeedbackFrame(frame));
     return true;
   }
 
-  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE {
+  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
     ++frame_count_;
     stop_waiting_frames_.push_back(new QuicStopWaitingFrame(frame));
     return true;
   }
 
-  virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE {
+  virtual bool OnPingFrame(const QuicPingFrame& frame) override {
     ++frame_count_;
     ping_frames_.push_back(new QuicPingFrame(frame));
     return true;
   }
 
-  virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
+  virtual void OnFecData(const QuicFecData& fec) override {
     ++fec_count_;
     fec_data_.push_back(new QuicFecData(fec));
   }
 
-  virtual void OnPacketComplete() OVERRIDE {
+  virtual void OnPacketComplete() override {
     ++complete_packets_;
   }
 
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
     rst_stream_frame_ = frame;
     return true;
   }
 
   virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) OVERRIDE {
+      const QuicConnectionCloseFrame& frame) override {
     connection_close_frame_ = frame;
     return true;
   }
 
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override {
     goaway_frame_ = frame;
     return true;
   }
 
   virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame)
-      OVERRIDE {
+      override {
     window_update_frame_ = frame;
     return true;
   }
 
-  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
+  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
     blocked_frame_ = frame;
     return true;
   }
diff --git a/net/quic/quic_headers_stream.cc b/net/quic/quic_headers_stream.cc
index 35dac3f..56b700e 100644
--- a/net/quic/quic_headers_stream.cc
+++ b/net/quic/quic_headers_stream.cc
@@ -30,7 +30,7 @@
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
-                           bool unidirectional) OVERRIDE {
+                           bool unidirectional) override {
     if (!stream_->IsConnected()) {
       return;
     }
@@ -48,7 +48,7 @@
     stream_->OnSynStream(stream_id, priority, fin);
   }
 
-  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
+  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) override {
     if (!stream_->IsConnected()) {
       return;
     }
@@ -58,7 +58,7 @@
 
   virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                         const char* header_data,
-                                        size_t len) OVERRIDE {
+                                        size_t len) override {
     if (!stream_->IsConnected()) {
       return false;
     }
@@ -69,7 +69,7 @@
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
-                                 bool fin) OVERRIDE {
+                                 bool fin) override {
     if (fin && len == 0) {
       // The framer invokes OnStreamFrameData with zero-length data and
       // fin = true after processing a SYN_STREAM or SYN_REPLY frame
@@ -79,65 +79,65 @@
     CloseConnection("SPDY DATA frame received.");
   }
 
-  virtual void OnError(SpdyFramer* framer) OVERRIDE {
+  virtual void OnError(SpdyFramer* framer) override {
     CloseConnection("SPDY framing error.");
   }
 
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
-                                 bool fin) OVERRIDE {
+                                 bool fin) override {
     CloseConnection("SPDY DATA frame received.");
   }
 
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE {
+                           SpdyRstStreamStatus status) override {
     CloseConnection("SPDY RST_STREAM frame received.");
   }
 
   virtual void OnSetting(SpdySettingsIds id,
                          uint8 flags,
-                         uint32 value) OVERRIDE {
+                         uint32 value) override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnSettingsAck() OVERRIDE {
+  virtual void OnSettingsAck() override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnSettingsEnd() OVERRIDE {
+  virtual void OnSettingsEnd() override {
     CloseConnection("SPDY SETTINGS frame received.");
   }
 
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {
     CloseConnection("SPDY PING frame received.");
   }
 
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE {
+                        SpdyGoAwayStatus status) override {
     CloseConnection("SPDY GOAWAY frame received.");
   }
 
-  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE {
+  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override {
     CloseConnection("SPDY HEADERS frame received.");
   }
 
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) OVERRIDE {
+                              uint32 delta_window_size) override {
     CloseConnection("SPDY WINDOW_UPDATE frame received.");
   }
 
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
-                             bool end) OVERRIDE {
+                             bool end) override {
     LOG(DFATAL) << "PUSH_PROMISE frame received from a SPDY/3 framer";
     CloseConnection("SPDY PUSH_PROMISE frame received.");
   }
 
-  virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
+  virtual void OnContinuation(SpdyStreamId stream_id, bool end) override {
     CloseConnection("SPDY CONTINUATION frame received.");
   }
 
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE {
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
     CloseConnection("SPDY unknown frame received.");
     return false;
   }
@@ -146,11 +146,11 @@
   virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
                                      SpdyFrameType type,
                                      size_t payload_len,
-                                     size_t frame_len) OVERRIDE {}
+                                     size_t frame_len) override {}
 
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
-                                        size_t frame_len) OVERRIDE {
+                                        size_t frame_len) override {
     if (stream_->IsConnected()) {
       stream_->OnCompressedFrameSize(frame_len);
     }
diff --git a/net/quic/quic_headers_stream.h b/net/quic/quic_headers_stream.h
index c3ccbda..fb96ec7 100644
--- a/net/quic/quic_headers_stream.h
+++ b/net/quic/quic_headers_stream.h
@@ -34,8 +34,8 @@
       QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
 
   // ReliableQuicStream implementation
-  virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE;
-  virtual QuicPriority EffectivePriority() const OVERRIDE;
+  virtual uint32 ProcessRawData(const char* data, uint32 data_len) override;
+  virtual QuicPriority EffectivePriority() const override;
 
  private:
   class SpdyFramerVisitor;
diff --git a/net/quic/quic_http_stream.h b/net/quic/quic_http_stream.h
index 5c60822..44e98e8 100644
--- a/net/quic/quic_http_stream.h
+++ b/net/quic/quic_http_stream.h
@@ -35,41 +35,41 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE;
-  virtual UploadProgress GetUploadProgress() const OVERRIDE;
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
+  virtual UploadProgress GetUploadProgress() const override;
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override;
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual void Close(bool not_reusable) OVERRIDE;
-  virtual HttpStream* RenewStreamForAuth() OVERRIDE;
-  virtual bool IsResponseBodyComplete() const OVERRIDE;
-  virtual bool CanFindEndOfResponse() const OVERRIDE;
-  virtual bool IsConnectionReused() const OVERRIDE;
-  virtual void SetConnectionReused() OVERRIDE;
-  virtual bool IsConnectionReusable() const OVERRIDE;
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual void Close(bool not_reusable) override;
+  virtual HttpStream* RenewStreamForAuth() override;
+  virtual bool IsResponseBodyComplete() const override;
+  virtual bool CanFindEndOfResponse() const override;
+  virtual bool IsConnectionReused() const override;
+  virtual void SetConnectionReused() override;
+  virtual bool IsConnectionReusable() const override;
+  virtual int64 GetTotalReceivedBytes() const override;
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override;
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
-  virtual bool IsSpdyHttpStream() const OVERRIDE;
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
+  virtual bool IsSpdyHttpStream() const override;
+  virtual void Drain(HttpNetworkSession* session) override;
+  virtual void SetPriority(RequestPriority priority) override;
 
   // QuicReliableClientStream::Delegate implementation
-  virtual int OnDataReceived(const char* data, int length) OVERRIDE;
-  virtual void OnClose(QuicErrorCode error) OVERRIDE;
-  virtual void OnError(int error) OVERRIDE;
-  virtual bool HasSendHeadersComplete() OVERRIDE;
+  virtual int OnDataReceived(const char* data, int length) override;
+  virtual void OnClose(QuicErrorCode error) override;
+  virtual void OnError(int error) override;
+  virtual bool HasSendHeadersComplete() override;
 
   // QuicClientSession::Observer implementation
-  virtual void OnCryptoHandshakeConfirmed() OVERRIDE;
-  virtual void OnSessionClosed(int error) OVERRIDE;
+  virtual void OnCryptoHandshakeConfirmed() override;
+  virtual void OnSessionClosed(int error) override;
 
  private:
   friend class test::QuicHttpStreamPeer;
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index 313e7f5..b6ecc77 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -6,10 +6,11 @@
 
 #include <vector>
 
+#include "net/base/chunked_upload_data_stream.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/transport_security_state.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
@@ -97,7 +98,7 @@
       : QuicHttpStream(session) {
   }
 
-  virtual int OnDataReceived(const char* data, int length) OVERRIDE {
+  virtual int OnDataReceived(const char* data, int length) override {
     Close(false);
     return OK;
   }
@@ -109,7 +110,7 @@
       : socket_(socket) {}
   virtual ~TestPacketWriterFactory() {}
 
-  virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE {
+  virtual QuicPacketWriter* Create(QuicConnection* connection) const override {
     return new QuicDefaultPacketWriter(socket_);
   }
 
@@ -224,7 +225,6 @@
     connection_->set_visitor(&visitor_);
     connection_->SetSendAlgorithm(send_algorithm_);
     connection_->SetReceiveAlgorithm(receive_algorithm_);
-    crypto_config_.SetDefaults();
     session_.reset(
         new QuicClientSession(connection_,
                               scoped_ptr<DatagramClientSocket>(socket),
@@ -489,7 +489,7 @@
   ScopedVector<UploadElementReader> element_readers;
   element_readers.push_back(
       new UploadBytesElementReader(kUploadData, strlen(kUploadData)));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
@@ -535,20 +535,21 @@
   AddWrite(ConstructAckPacket(4, 3, 1));
   Initialize();
 
-  UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0);
-  upload_data_stream.AppendChunk(kUploadData, chunk_size, false);
+  ChunkedUploadDataStream upload_data_stream(0);
+  upload_data_stream.AppendData(kUploadData, chunk_size, false);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
-  ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
+  ASSERT_EQ(OK, request_.upload_data_stream->Init(
+      TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
 
-  upload_data_stream.AppendChunk(kUploadData, chunk_size, true);
+  upload_data_stream.AppendData(kUploadData, chunk_size, true);
 
   // Ack both packets in the request.
   ProcessPacket(ConstructAckPacket(1, 0, 0));
@@ -586,20 +587,21 @@
   AddWrite(ConstructAckPacket(4, 3, 1));
   Initialize();
 
-  UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0);
-  upload_data_stream.AppendChunk(kUploadData, chunk_size, false);
+  ChunkedUploadDataStream upload_data_stream(0);
+  upload_data_stream.AppendData(kUploadData, chunk_size, false);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
-  ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
+  ASSERT_EQ(OK, request_.upload_data_stream->Init(
+      TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
 
-  upload_data_stream.AppendChunk(nullptr, 0, true);
+  upload_data_stream.AppendData(nullptr, 0, true);
 
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
@@ -634,19 +636,20 @@
   AddWrite(ConstructAckPacket(3, 3, 1));
   Initialize();
 
-  UploadDataStream upload_data_stream(UploadDataStream::CHUNKED, 0);
+  ChunkedUploadDataStream upload_data_stream(0);
 
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
-  ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
+  ASSERT_EQ(OK, request_.upload_data_stream->Init(
+      TestCompletionCallback().callback()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
 
-  upload_data_stream.AppendChunk(nullptr, 0, true);
+  upload_data_stream.AppendData(nullptr, 0, true);
 
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
diff --git a/net/quic/quic_packet_creator.h b/net/quic/quic_packet_creator.h
index 313632e..cb4cb05 100644
--- a/net/quic/quic_packet_creator.h
+++ b/net/quic/quic_packet_creator.h
@@ -38,7 +38,7 @@
 
   // QuicFecBuilderInterface
   virtual void OnBuiltFecProtectedPayload(const QuicPacketHeader& header,
-                                          base::StringPiece payload) OVERRIDE;
+                                          base::StringPiece payload) override;
 
   // Turn on FEC protection for subsequently created packets. FEC should be
   // enabled first (max_packets_per_fec_group should be non-zero) for FEC
diff --git a/net/quic/quic_packet_creator_test.cc b/net/quic/quic_packet_creator_test.cc
index c8d5686..0872762 100644
--- a/net/quic/quic_packet_creator_test.cc
+++ b/net/quic/quic_packet_creator_test.cc
@@ -75,7 +75,7 @@
     server_framer_.set_visitor(&framer_visitor_);
   }
 
-  virtual ~QuicPacketCreatorTest() OVERRIDE {
+  virtual ~QuicPacketCreatorTest() override {
   }
 
   void ProcessPacket(QuicPacket* packet) {
diff --git a/net/quic/quic_packet_generator_test.cc b/net/quic/quic_packet_generator_test.cc
index 703fd64..190e8a7 100644
--- a/net/quic/quic_packet_generator_test.cc
+++ b/net/quic/quic_packet_generator_test.cc
@@ -33,7 +33,7 @@
 class MockDelegate : public QuicPacketGenerator::DelegateInterface {
  public:
   MockDelegate() {}
-  virtual ~MockDelegate() OVERRIDE {}
+  virtual ~MockDelegate() override {}
 
   MOCK_METHOD3(ShouldGeneratePacket,
                bool(TransmissionType transmission_type,
@@ -116,7 +116,7 @@
         packet6_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr),
         packet7_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr) {}
 
-  virtual ~QuicPacketGeneratorTest() OVERRIDE {
+  virtual ~QuicPacketGeneratorTest() override {
     delete packet_.packet;
     delete packet_.retransmittable_frames;
     delete packet2_.packet;
diff --git a/net/quic/quic_per_connection_packet_writer.h b/net/quic/quic_per_connection_packet_writer.h
index 9b9b912..4e5e8c8 100644
--- a/net/quic/quic_per_connection_packet_writer.h
+++ b/net/quic/quic_per_connection_packet_writer.h
@@ -32,10 +32,10 @@
   virtual WriteResult WritePacket(const char* buffer,
                                   size_t buf_len,
                                   const IPAddressNumber& self_address,
-                                  const IPEndPoint& peer_address) OVERRIDE;
-  virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
-  virtual bool IsWriteBlocked() const OVERRIDE;
-  virtual void SetWritable() OVERRIDE;
+                                  const IPEndPoint& peer_address) override;
+  virtual bool IsWriteBlockedDataBuffered() const override;
+  virtual bool IsWriteBlocked() const override;
+  virtual void SetWritable() override;
 
  private:
   void OnWriteComplete(WriteResult result);
diff --git a/net/quic/quic_protocol.h b/net/quic/quic_protocol.h
index 6a1bec5..47be63c 100644
--- a/net/quic/quic_protocol.h
+++ b/net/quic/quic_protocol.h
@@ -106,7 +106,7 @@
 const QuicStreamId kHeadersStreamId = 3;
 
 // Maximum delayed ack time, in ms.
-const int kMaxDelayedAckTimeMs = 25;
+const int64 kMaxDelayedAckTimeMs = 25;
 
 // The timeout before the handshake succeeds.
 const int64 kInitialIdleTimeoutSecs = 5;
@@ -117,6 +117,10 @@
 // The default timeout for a connection until the crypto handshake succeeds.
 const int64 kMaxTimeForCryptoHandshakeSecs = 10;  // 10 secs.
 
+// Default limit on the number of undecryptable packets the connection buffers
+// before the CHLO/SHLO arrive.
+const size_t kDefaultMaxUndecryptablePackets = 10;
+
 // Default ping timeout.
 const int64 kPingTimeoutSecs = 15;  // 15 secs.
 
diff --git a/net/quic/quic_received_packet_manager.cc b/net/quic/quic_received_packet_manager.cc
index 255ce4d..187f8e0 100644
--- a/net/quic/quic_received_packet_manager.cc
+++ b/net/quic/quic_received_packet_manager.cc
@@ -167,7 +167,7 @@
     uint32 sequence_gap = ack_frame_.largest_observed - sequence_number;
     stats_->max_sequence_reordering =
         max(stats_->max_sequence_reordering, sequence_gap);
-    uint32 reordering_time_us =
+    int64 reordering_time_us =
         receipt_time.Subtract(time_largest_observed_).ToMicroseconds();
     stats_->max_time_reordering_us = max(stats_->max_time_reordering_us,
                                          reordering_time_us);
@@ -229,14 +229,11 @@
     return;
   }
 
-  if (approximate_now < time_largest_observed_) {
-    // Approximate now may well be "in the past".
-    ack_frame->delta_time_largest_observed = QuicTime::Delta::Zero();
-    return;
-  }
-
+  // Ensure the delta is zero if approximate now is "in the past".
   ack_frame->delta_time_largest_observed =
-      approximate_now.Subtract(time_largest_observed_);
+      approximate_now < time_largest_observed_ ?
+          QuicTime::Delta::Zero() :
+          approximate_now.Subtract(time_largest_observed_);
 
   // Remove all packets that are too far from largest_observed to express.
   received_packet_times_.remove_if(isTooLarge(ack_frame_.largest_observed));
diff --git a/net/quic/quic_received_packet_manager.h b/net/quic/quic_received_packet_manager.h
index 1231891..9eccfe0 100644
--- a/net/quic/quic_received_packet_manager.h
+++ b/net/quic/quic_received_packet_manager.h
@@ -129,7 +129,7 @@
   // Called by QuicFramer, when the outgoing ack gets truncated, to recalculate
   // the received entropy hash for the truncated ack frame.
   virtual QuicPacketEntropyHash EntropyHash(
-      QuicPacketSequenceNumber sequence_number) const OVERRIDE;
+      QuicPacketSequenceNumber sequence_number) const override;
 
   // Updates internal state based on |stop_waiting|.
   void UpdatePacketInformationSentByPeer(
diff --git a/net/quic/quic_received_packet_manager_test.cc b/net/quic/quic_received_packet_manager_test.cc
index 9e8c128..b64025b 100644
--- a/net/quic/quic_received_packet_manager_test.cc
+++ b/net/quic/quic_received_packet_manager_test.cc
@@ -238,7 +238,7 @@
   }
   // Reorder by 5 when 2 is received after 7.
   EXPECT_EQ(5u, stats_.max_sequence_reordering);
-  EXPECT_EQ(0u, stats_.max_time_reordering_us);
+  EXPECT_EQ(0, stats_.max_time_reordering_us);
   EXPECT_EQ(2u, stats_.packets_reordered);
 }
 
@@ -285,7 +285,7 @@
 
   // No reordering.
   EXPECT_EQ(0u, stats_.max_sequence_reordering);
-  EXPECT_EQ(0u, stats_.max_time_reordering_us);
+  EXPECT_EQ(0, stats_.max_time_reordering_us);
   EXPECT_EQ(0u, stats_.packets_reordered);
 }
 
@@ -314,6 +314,7 @@
   // When UpdateReceivedPacketInfo with a time earlier than the time of the
   // largest observed packet, make sure that the delta is 0, not negative.
   EXPECT_EQ(QuicTime::Delta::Zero(), ack.delta_time_largest_observed);
+  EXPECT_FALSE(ack.received_packet_times.empty());
 
   QuicTime four_ms = QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(4));
   received_manager_.UpdateReceivedPacketInfo(&ack, four_ms);
@@ -330,7 +331,7 @@
       2, 0, QuicTime::Zero().Add(QuicTime::Delta::FromMilliseconds(1)));
 
   EXPECT_EQ(4u, stats_.max_sequence_reordering);
-  EXPECT_EQ(1000u, stats_.max_time_reordering_us);
+  EXPECT_EQ(1000, stats_.max_time_reordering_us);
   EXPECT_EQ(1u, stats_.packets_reordered);
 }
 
diff --git a/net/quic/quic_reliable_client_stream.h b/net/quic/quic_reliable_client_stream.h
index 2d5b818..065db9e 100644
--- a/net/quic/quic_reliable_client_stream.h
+++ b/net/quic/quic_reliable_client_stream.h
@@ -54,10 +54,10 @@
   virtual ~QuicReliableClientStream();
 
   // QuicDataStream
-  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE;
-  virtual void OnFinRead() OVERRIDE;
-  virtual void OnCanWrite() OVERRIDE;
-  virtual QuicPriority EffectivePriority() const OVERRIDE;
+  virtual uint32 ProcessData(const char* data, uint32 data_len) override;
+  virtual void OnFinRead() override;
+  virtual void OnCanWrite() override;
+  virtual QuicPriority EffectivePriority() const override;
 
   // While the server's set_priority shouldn't be called externally, the creator
   // of client-side streams should be able to set the priority.
diff --git a/net/quic/quic_sent_packet_manager.cc b/net/quic/quic_sent_packet_manager.cc
index a062827..3e81e74 100644
--- a/net/quic/quic_sent_packet_manager.cc
+++ b/net/quic/quic_sent_packet_manager.cc
@@ -26,17 +26,17 @@
 int32 FLAGS_quic_recent_min_rtt_window_s = 60;
 
 namespace {
-static const int kDefaultRetransmissionTimeMs = 500;
+static const int64 kDefaultRetransmissionTimeMs = 500;
 // TCP RFC calls for 1 second RTO however Linux differs from this default and
 // define the minimum RTO to 200ms, we will use the same until we have data to
 // support a higher or lower value.
-static const int kMinRetransmissionTimeMs = 200;
-static const int kMaxRetransmissionTimeMs = 60000;
+static const int64 kMinRetransmissionTimeMs = 200;
+static const int64 kMaxRetransmissionTimeMs = 60000;
 static const size_t kMaxRetransmissions = 10;
 
 // Only exponentially back off the handshake timer 5 times due to a timeout.
 static const size_t kMaxHandshakeRetransmissionBackoffs = 5;
-static const size_t kMinHandshakeTimeoutMs = 10;
+static const int64 kMinHandshakeTimeoutMs = 10;
 
 // Sends up to two tail loss probes before firing an RTO,
 // per draft RFC draft-dukkipati-tcpm-tcp-loss-probe.
@@ -452,7 +452,7 @@
     QuicTime::Delta delta_largest_observed) {
   QuicPacketSequenceNumber newest_transmission =
       info.all_transmissions == nullptr ? sequence_number
-      : *info.all_transmissions->rbegin();
+                                        : *info.all_transmissions->rbegin();
   // Remove the most recent packet, if it is pending retransmission.
   pending_retransmissions_.erase(newest_transmission);
 
@@ -503,13 +503,6 @@
   DCHECK_LT(0u, sequence_number);
   DCHECK(!unacked_packets_.IsUnacked(sequence_number));
   LOG_IF(DFATAL, bytes == 0) << "Cannot send empty packets.";
-  if (debug_delegate_ != nullptr) {
-    debug_delegate_->OnSentPacket(*serialized_packet,
-                                  original_sequence_number,
-                                  sent_time,
-                                  bytes,
-                                  transmission_type);
-  }
 
   if (original_sequence_number == 0) {
     if (serialized_packet->retransmittable_frames) {
@@ -765,7 +758,7 @@
 // of (likely, tail) latency, then consider such a mechanism.
 const QuicTime::Delta QuicSentPacketManager::DelayedAckTime() const {
   return QuicTime::Delta::FromMilliseconds(min(kMaxDelayedAckTimeMs,
-                                               kMinRetransmissionTimeMs/2));
+                                               kMinRetransmissionTimeMs / 2));
 }
 
 const QuicTime QuicSentPacketManager::GetRetransmissionTime() const {
@@ -808,8 +801,9 @@
     const {
   // This is equivalent to the TailLossProbeDelay, but slightly more aggressive
   // because crypto handshake messages don't incur a delayed ack time.
-  int64 delay_ms = max<int64>(kMinHandshakeTimeoutMs,
-                              1.5 * rtt_stats_.SmoothedRtt().ToMilliseconds());
+  int64 delay_ms =
+      max(kMinHandshakeTimeoutMs,
+          static_cast<int64>(1.5 * rtt_stats_.SmoothedRtt().ToMilliseconds()));
   return QuicTime::Delta::FromMilliseconds(
       delay_ms << consecutive_crypto_retransmission_count_);
 }
@@ -818,8 +812,9 @@
   QuicTime::Delta srtt = rtt_stats_.SmoothedRtt();
   if (!unacked_packets_.HasMultipleInFlightPackets()) {
     return QuicTime::Delta::Max(
-        srtt.Multiply(2), srtt.Multiply(1.5)
-          .Add(QuicTime::Delta::FromMilliseconds(kMinRetransmissionTimeMs/2)));
+        srtt.Multiply(2),
+        srtt.Multiply(1.5).Add(
+            QuicTime::Delta::FromMilliseconds(kMinRetransmissionTimeMs / 2)));
   }
   return QuicTime::Delta::FromMilliseconds(
       max(kMinTailLossProbeTimeoutMs,
diff --git a/net/quic/quic_sent_packet_manager.h b/net/quic/quic_sent_packet_manager.h
index 2b5f738..f5be3fd 100644
--- a/net/quic/quic_sent_packet_manager.h
+++ b/net/quic/quic_sent_packet_manager.h
@@ -51,13 +51,6 @@
         TransmissionType transmission_type,
         QuicByteCount byte_size) {}
 
-    virtual void OnSentPacket(
-        const SerializedPacket& packet,
-        QuicPacketSequenceNumber original_sequence_number,
-        QuicTime sent_time,
-        QuicByteCount bytes,
-        TransmissionType transmission_type) {}
-
     virtual void OnIncomingAck(
         const QuicAckFrame& ack_frame,
         QuicTime ack_receive_time,
diff --git a/net/quic/quic_sent_packet_manager_test.cc b/net/quic/quic_sent_packet_manager_test.cc
index 42c9a6f..3260ab1 100644
--- a/net/quic/quic_sent_packet_manager_test.cc
+++ b/net/quic/quic_sent_packet_manager_test.cc
@@ -63,7 +63,7 @@
     EXPECT_CALL(*send_algorithm_, InRecovery()).Times(AnyNumber());
   }
 
-  virtual ~QuicSentPacketManagerTest() OVERRIDE {
+  virtual ~QuicSentPacketManagerTest() override {
     STLDeleteElements(&packets_);
   }
 
diff --git a/net/quic/quic_server_bin.cc b/net/quic/quic_server_bin.cc
index 63b85a7..320f3da 100644
--- a/net/quic/quic_server_bin.cc
+++ b/net/quic/quic_server_bin.cc
@@ -55,15 +55,12 @@
   }
 
   base::AtExitManager exit_manager;
-
   base::MessageLoopForIO message_loop;
 
   net::IPAddressNumber ip;
   CHECK(net::ParseIPLiteralToNumber("::", &ip));
 
   net::QuicConfig config;
-  config.SetDefaults();
-
   net::QuicServer server(config, net::QuicSupportedVersions());
 
   int rc = server.Listen(net::IPEndPoint(ip, FLAGS_port));
diff --git a/net/quic/quic_server_packet_writer.h b/net/quic/quic_server_packet_writer.h
index 417ea8d..15c946b 100644
--- a/net/quic/quic_server_packet_writer.h
+++ b/net/quic/quic_server_packet_writer.h
@@ -41,16 +41,16 @@
   void OnWriteComplete(int rv);
 
   // QuicPacketWriter implementation:
-  virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
-  virtual bool IsWriteBlocked() const OVERRIDE;
-  virtual void SetWritable() OVERRIDE;
+  virtual bool IsWriteBlockedDataBuffered() const override;
+  virtual bool IsWriteBlocked() const override;
+  virtual void SetWritable() override;
 
  protected:
   // Do not call WritePacket on its own -- use WritePacketWithCallback
   virtual WriteResult WritePacket(const char* buffer,
                                   size_t buf_len,
                                   const IPAddressNumber& self_address,
-                                  const IPEndPoint& peer_address) OVERRIDE;
+                                  const IPEndPoint& peer_address) override;
  private:
   UDPServerSocket* socket_;
 
diff --git a/net/quic/quic_server_session.cc b/net/quic/quic_server_session.cc
index bacd59e..f2967a5 100644
--- a/net/quic/quic_server_session.cc
+++ b/net/quic/quic_server_session.cc
@@ -13,10 +13,9 @@
 
 namespace net {
 
-QuicServerSession::QuicServerSession(
-    const QuicConfig& config,
-    QuicConnection* connection,
-    QuicServerSessionVisitor* visitor)
+QuicServerSession::QuicServerSession(const QuicConfig& config,
+                                     QuicConnection* connection,
+                                     QuicServerSessionVisitor* visitor)
     : QuicSession(connection, config),
       visitor_(visitor),
       bandwidth_estimate_sent_to_client_(QuicBandwidth::Zero()),
@@ -134,7 +133,7 @@
     cached_network_params.set_serving_region(serving_region_);
   }
 
-  crypto_stream_->SendServerConfigUpdate(&cached_network_params);
+  crypto_stream_->SendServerConfigUpdate(&cached_network_params, false);
   last_server_config_update_time_ = now;
 }
 
diff --git a/net/quic/quic_server_session.h b/net/quic/quic_server_session.h
index a2e4feb..80b6443 100644
--- a/net/quic/quic_server_session.h
+++ b/net/quic/quic_server_session.h
@@ -49,12 +49,12 @@
                     QuicServerSessionVisitor* visitor);
 
   // Override the base class to notify the owner of the connection close.
-  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
-  virtual void OnWriteBlocked() OVERRIDE;
+  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
+  virtual void OnWriteBlocked() override;
 
   // Sends a server config update to the client, containing new bandwidth
   // estimate.
-  virtual void OnCongestionWindowChange(QuicTime now) OVERRIDE;
+  virtual void OnCongestionWindowChange(QuicTime now) override;
 
   virtual ~QuicServerSession();
 
@@ -65,7 +65,7 @@
   }
 
   // Override base class to process FEC config received from client.
-  virtual void OnConfigNegotiated() OVERRIDE;
+  virtual void OnConfigNegotiated() override;
 
   void set_serving_region(string serving_region) {
     serving_region_ = serving_region;
@@ -73,9 +73,9 @@
 
  protected:
   // QuicSession methods:
-  virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE;
-  virtual QuicDataStream* CreateOutgoingDataStream() OVERRIDE;
-  virtual QuicCryptoServerStream* GetCryptoStream() OVERRIDE;
+  virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) override;
+  virtual QuicDataStream* CreateOutgoingDataStream() override;
+  virtual QuicCryptoServerStream* GetCryptoStream() override;
 
   // If we should create an incoming stream, returns true. Otherwise
   // does error handling, including communicating the error to the client and
diff --git a/net/quic/quic_session.cc b/net/quic/quic_session.cc
index cef5656..3299e71 100644
--- a/net/quic/quic_session.cc
+++ b/net/quic/quic_session.cc
@@ -34,65 +34,65 @@
  public:
   explicit VisitorShim(QuicSession* session) : session_(session) {}
 
-  virtual void OnStreamFrames(const vector<QuicStreamFrame>& frames) OVERRIDE {
+  virtual void OnStreamFrames(const vector<QuicStreamFrame>& frames) override {
     session_->OnStreamFrames(frames);
     session_->PostProcessAfterData();
   }
-  virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE {
+  virtual void OnRstStream(const QuicRstStreamFrame& frame) override {
     session_->OnRstStream(frame);
     session_->PostProcessAfterData();
   }
 
-  virtual void OnGoAway(const QuicGoAwayFrame& frame) OVERRIDE {
+  virtual void OnGoAway(const QuicGoAwayFrame& frame) override {
     session_->OnGoAway(frame);
     session_->PostProcessAfterData();
   }
 
   virtual void OnWindowUpdateFrames(const vector<QuicWindowUpdateFrame>& frames)
-      OVERRIDE {
+      override {
     session_->OnWindowUpdateFrames(frames);
     session_->PostProcessAfterData();
   }
 
   virtual void OnBlockedFrames(const vector<QuicBlockedFrame>& frames)
-      OVERRIDE {
+      override {
     session_->OnBlockedFrames(frames);
     session_->PostProcessAfterData();
   }
 
-  virtual void OnCanWrite() OVERRIDE {
+  virtual void OnCanWrite() override {
     session_->OnCanWrite();
     session_->PostProcessAfterData();
   }
 
-  virtual void OnCongestionWindowChange(QuicTime now) OVERRIDE {
+  virtual void OnCongestionWindowChange(QuicTime now) override {
     session_->OnCongestionWindowChange(now);
   }
 
   virtual void OnSuccessfulVersionNegotiation(
-      const QuicVersion& version) OVERRIDE {
+      const QuicVersion& version) override {
     session_->OnSuccessfulVersionNegotiation(version);
   }
 
   virtual void OnConnectionClosed(
-      QuicErrorCode error, bool from_peer) OVERRIDE {
+      QuicErrorCode error, bool from_peer) override {
     session_->OnConnectionClosed(error, from_peer);
     // The session will go away, so don't bother with cleanup.
   }
 
-  virtual void OnWriteBlocked() OVERRIDE {
+  virtual void OnWriteBlocked() override {
     session_->OnWriteBlocked();
   }
 
-  virtual bool WillingAndAbleToWrite() const OVERRIDE {
+  virtual bool WillingAndAbleToWrite() const override {
     return session_->WillingAndAbleToWrite();
   }
 
-  virtual bool HasPendingHandshake() const OVERRIDE {
+  virtual bool HasPendingHandshake() const override {
     return session_->HasPendingHandshake();
   }
 
-  virtual bool HasOpenDataStreams() const OVERRIDE {
+  virtual bool HasOpenDataStreams() const override {
     return session_->HasOpenDataStreams();
   }
 
@@ -528,12 +528,12 @@
 
   // Inform all existing streams about the new window.
   if (connection_->version() >= QUIC_VERSION_21) {
-    GetCryptoStream()->flow_controller()->UpdateSendWindowOffset(new_window);
-    headers_stream_->flow_controller()->UpdateSendWindowOffset(new_window);
+    GetCryptoStream()->UpdateSendWindowOffset(new_window);
+    headers_stream_->UpdateSendWindowOffset(new_window);
   }
   for (DataStreamMap::iterator it = stream_map_.begin();
        it != stream_map_.end(); ++it) {
-    it->second->flow_controller()->UpdateSendWindowOffset(new_window);
+    it->second->UpdateSendWindowOffset(new_window);
   }
 }
 
@@ -782,4 +782,22 @@
   }
 }
 
+bool QuicSession::IsConnectionFlowControlBlocked() const {
+  return flow_controller_->IsBlocked();
+}
+
+bool QuicSession::IsStreamFlowControlBlocked() {
+  if (headers_stream_->flow_controller()->IsBlocked() ||
+      GetCryptoStream()->flow_controller()->IsBlocked()) {
+    return true;
+  }
+  for (DataStreamMap::iterator it = stream_map_.begin();
+       it != stream_map_.end(); ++it) {
+    if (it->second->flow_controller()->IsBlocked()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 }  // namespace net
diff --git a/net/quic/quic_session.h b/net/quic/quic_session.h
index 7a52fba..6414b6d 100644
--- a/net/quic/quic_session.h
+++ b/net/quic/quic_session.h
@@ -59,22 +59,22 @@
 
   // QuicConnectionVisitorInterface methods:
   virtual void OnStreamFrames(
-      const std::vector<QuicStreamFrame>& frames) OVERRIDE;
-  virtual void OnRstStream(const QuicRstStreamFrame& frame) OVERRIDE;
-  virtual void OnGoAway(const QuicGoAwayFrame& frame) OVERRIDE;
+      const std::vector<QuicStreamFrame>& frames) override;
+  virtual void OnRstStream(const QuicRstStreamFrame& frame) override;
+  virtual void OnGoAway(const QuicGoAwayFrame& frame) override;
   virtual void OnWindowUpdateFrames(
-      const std::vector<QuicWindowUpdateFrame>& frames) OVERRIDE;
+      const std::vector<QuicWindowUpdateFrame>& frames) override;
   virtual void OnBlockedFrames(
-      const std::vector<QuicBlockedFrame>& frames) OVERRIDE;
-  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
-  virtual void OnWriteBlocked() OVERRIDE {}
+      const std::vector<QuicBlockedFrame>& frames) override;
+  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
+  virtual void OnWriteBlocked() override {}
   virtual void OnSuccessfulVersionNegotiation(
-      const QuicVersion& version) OVERRIDE;
-  virtual void OnCanWrite() OVERRIDE;
-  virtual void OnCongestionWindowChange(QuicTime now) OVERRIDE {}
-  virtual bool WillingAndAbleToWrite() const OVERRIDE;
-  virtual bool HasPendingHandshake() const OVERRIDE;
-  virtual bool HasOpenDataStreams() const OVERRIDE;
+      const QuicVersion& version) override;
+  virtual void OnCanWrite() override;
+  virtual void OnCongestionWindowChange(QuicTime now) override {}
+  virtual bool WillingAndAbleToWrite() const override;
+  virtual bool HasPendingHandshake() const override;
+  virtual bool HasOpenDataStreams() const override;
 
   // Called by the headers stream when headers have been received for a stream.
   virtual void OnStreamHeaders(QuicStreamId stream_id,
@@ -206,6 +206,12 @@
 
   QuicFlowController* flow_controller() { return flow_controller_.get(); }
 
+  // Returns true if connection is flow controller blocked.
+  bool IsConnectionFlowControlBlocked() const;
+
+  // Returns true if any stream is flow controller blocked.
+  bool IsStreamFlowControlBlocked();
+
   size_t get_max_open_streams() const { return max_open_streams_; }
 
  protected:
diff --git a/net/quic/quic_session_test.cc b/net/quic/quic_session_test.cc
index a36b77c..770a564 100644
--- a/net/quic/quic_session_test.cc
+++ b/net/quic/quic_session_test.cc
@@ -9,6 +9,8 @@
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
+#include "base/rand_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_crypto_stream.h"
 #include "net/quic/quic_flags.h"
@@ -52,7 +54,7 @@
   }
 
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE {
+      const CryptoHandshakeMessage& message) override {
     encryption_established_ = true;
     handshake_confirmed_ = true;
     CryptoHandshakeMessage msg;
@@ -91,7 +93,7 @@
 
   using ReliableQuicStream::CloseWriteSide;
 
-  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE {
+  virtual uint32 ProcessData(const char* data, uint32 data_len) override {
     return data_len;
   }
 
@@ -129,17 +131,17 @@
     InitializeSession();
   }
 
-  virtual TestCryptoStream* GetCryptoStream() OVERRIDE {
+  virtual TestCryptoStream* GetCryptoStream() override {
     return &crypto_stream_;
   }
 
-  virtual TestStream* CreateOutgoingDataStream() OVERRIDE {
+  virtual TestStream* CreateOutgoingDataStream() override {
     TestStream* stream = new TestStream(GetNextStreamId(), this);
     ActivateStream(stream);
     return stream;
   }
 
-  virtual TestStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE {
+  virtual TestStream* CreateIncomingDataStream(QuicStreamId id) override {
     return new TestStream(id, this);
   }
 
@@ -157,7 +159,7 @@
       QuicStreamOffset offset,
       bool fin,
       FecProtection fec_protection,
-      QuicAckNotifier::DelegateInterface* ack_notifier_delegate) OVERRIDE {
+      QuicAckNotifier::DelegateInterface* ack_notifier_delegate) override {
     // Always consumes everything.
     if (writev_consumes_all_data_) {
       return QuicConsumedData(data.TotalBufferSize(), fin);
@@ -534,6 +536,8 @@
   // Ensure connection level flow control blockage.
   QuicFlowControllerPeer::SetSendWindowOffset(session_.flow_controller(), 0);
   EXPECT_TRUE(session_.flow_controller()->IsBlocked());
+  EXPECT_TRUE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
 
   // Mark the crypto and headers streams as write blocked, we expect them to be
   // allowed to write later.
@@ -579,11 +583,11 @@
 
 TEST_P(QuicSessionTest, IncreasedTimeoutAfterCryptoHandshake) {
   EXPECT_EQ((FLAGS_quic_unified_timeouts ?
-             kInitialIdleTimeoutSecs : kDefaultIdleTimeoutSecs) + 1,
+             kInitialIdleTimeoutSecs : kDefaultIdleTimeoutSecs) + 3,
             QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
   CryptoHandshakeMessage msg;
   session_.GetCryptoStream()->OnHandshakeMessage(msg);
-  EXPECT_EQ(kMaximumIdleTimeoutSecs + 1,
+  EXPECT_EQ(kMaximumIdleTimeoutSecs + 3,
             QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
 }
 
@@ -641,9 +645,16 @@
   TestStream* stream2 = session_.CreateOutgoingDataStream();
   string body(kDefaultFlowControlSendWindow, '.');
   EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
   stream2->SendBody(body, false);
   EXPECT_TRUE(stream2->flow_controller()->IsBlocked());
+  EXPECT_TRUE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
 
+  // The handshake message will call OnCanWrite, so the stream can resume
+  // writing.
+  EXPECT_CALL(*stream2, OnCanWrite());
   // Now complete the crypto handshake, resulting in an increased flow control
   // send window.
   CryptoHandshakeMessage msg;
@@ -651,6 +662,103 @@
 
   // Stream is now unblocked.
   EXPECT_FALSE(stream2->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+}
+
+TEST_P(QuicSessionTest, HandshakeUnblocksFlowControlBlockedCryptoStream) {
+  if (version() <= QUIC_VERSION_19) {
+    return;
+  }
+  // Test that if the crypto stream is flow control blocked, then if the SHLO
+  // contains a larger send window offset, the stream becomes unblocked.
+  session_.set_writev_consumes_all_data(true);
+  TestCryptoStream* crypto_stream = session_.GetCryptoStream();
+  EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+  QuicHeadersStream* headers_stream =
+      QuicSessionPeer::GetHeadersStream(&session_);
+  EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+  // Write until the crypto stream is flow control blocked.
+  int i = 0;
+  while (!crypto_stream->flow_controller()->IsBlocked() && i < 1000) {
+    EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+    EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+    QuicConfig config;
+    CryptoHandshakeMessage crypto_message;
+    config.ToHandshakeMessage(&crypto_message);
+    crypto_stream->SendHandshakeMessage(crypto_message);
+    ++i;
+  }
+  EXPECT_TRUE(crypto_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
+  EXPECT_FALSE(session_.HasDataToWrite());
+  EXPECT_TRUE(crypto_stream->HasBufferedData());
+
+  // The handshake message will call OnCanWrite, so the stream can
+  // resume writing.
+  EXPECT_CALL(*crypto_stream, OnCanWrite());
+  // Now complete the crypto handshake, resulting in an increased flow control
+  // send window.
+  CryptoHandshakeMessage msg;
+  session_.GetCryptoStream()->OnHandshakeMessage(msg);
+
+  // Stream is now unblocked and will no longer have buffered data.
+  EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+}
+
+TEST_P(QuicSessionTest, HandshakeUnblocksFlowControlBlockedHeadersStream) {
+  if (version() <= QUIC_VERSION_19) {
+    return;
+  }
+  // Test that if the header stream is flow control blocked, then if the SHLO
+  // contains a larger send window offset, the stream becomes unblocked.
+  session_.set_writev_consumes_all_data(true);
+  TestCryptoStream* crypto_stream = session_.GetCryptoStream();
+  EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+  QuicHeadersStream* headers_stream =
+      QuicSessionPeer::GetHeadersStream(&session_);
+  EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+  QuicStreamId stream_id = 5;
+  // Write until the header stream is flow control blocked.
+  while (!headers_stream->flow_controller()->IsBlocked() && stream_id < 2000) {
+    EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+    EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+    SpdyHeaderBlock headers;
+    headers["header"] = base::Uint64ToString(base::RandUint64()) +
+        base::Uint64ToString(base::RandUint64()) +
+        base::Uint64ToString(base::RandUint64());
+    headers_stream->WriteHeaders(stream_id, headers, true, nullptr);
+    stream_id += 2;
+  }
+  EXPECT_TRUE(headers_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(crypto_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
+  EXPECT_FALSE(session_.HasDataToWrite());
+  EXPECT_TRUE(headers_stream->HasBufferedData());
+
+  // Now complete the crypto handshake, resulting in an increased flow control
+  // send window.
+  CryptoHandshakeMessage msg;
+  session_.GetCryptoStream()->OnHandshakeMessage(msg);
+
+  // Stream is now unblocked and will no longer have buffered data.
+  EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
+  EXPECT_FALSE(headers_stream->HasBufferedData());
 }
 
 TEST_P(QuicSessionTest, InvalidFlowControlWindowInHandshake) {
@@ -906,6 +1014,8 @@
   QuicFlowControllerPeer::SetSendWindowOffset(headers_stream->flow_controller(),
                                               0);
   EXPECT_TRUE(headers_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_TRUE(session_.IsStreamFlowControlBlocked());
 
   // Unblock the headers stream by supplying a WINDOW_UPDATE.
   QuicWindowUpdateFrame window_update_frame(headers_stream->id(),
@@ -914,6 +1024,8 @@
   frames.push_back(window_update_frame);
   session_.OnWindowUpdateFrames(frames);
   EXPECT_FALSE(headers_stream->flow_controller()->IsBlocked());
+  EXPECT_FALSE(session_.IsConnectionFlowControlBlocked());
+  EXPECT_FALSE(session_.IsStreamFlowControlBlocked());
 }
 
 TEST_P(QuicSessionTest, TooManyUnfinishedStreamsCauseConnectionClose) {
diff --git a/net/quic/quic_spdy_server_stream.h b/net/quic/quic_spdy_server_stream.h
index 3cecb6b..afd1291 100644
--- a/net/quic/quic_spdy_server_stream.h
+++ b/net/quic/quic_spdy_server_stream.h
@@ -31,8 +31,8 @@
 
   // ReliableQuicStream implementation called by the session when there's
   // data for us.
-  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE;
-  virtual void OnFinRead() OVERRIDE;
+  virtual uint32 ProcessData(const char* data, uint32 data_len) override;
+  virtual void OnFinRead() override;
 
   void ParseRequestHeaders();
 
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index ccbca64..687ea4c 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -70,6 +70,8 @@
 const int32 kServerSecureInitialCongestionWindow = 32;
 // Be conservative, and just use double a typical TCP  ICWND for HTTP.
 const int32 kServerInecureInitialCongestionWindow = 20;
+// Set the maximum number of undecryptable packets the connection will store.
+const int32 kMaxUndecryptablePackets = 100;
 
 const char kDummyHostname[] = "quic.global.props";
 const uint16 kDummyPort = 0;
@@ -90,7 +92,6 @@
 
 QuicConfig InitializeQuicConfig(const QuicTagVector& connection_options) {
   QuicConfig config;
-  config.SetDefaults();
   config.SetIdleConnectionStateLifetime(
       QuicTime::Delta::FromSeconds(kIdleConnectionTimeoutSeconds),
       QuicTime::Delta::FromSeconds(kIdleConnectionTimeoutSeconds));
@@ -104,7 +105,7 @@
       : socket_(socket) {}
   virtual ~DefaultPacketWriterFactory() {}
 
-  virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE;
+  virtual QuicPacketWriter* Create(QuicConnection* connection) const override;
 
  private:
   DatagramClientSocket* socket_;
@@ -511,7 +512,6 @@
       check_persisted_supports_quic_(true),
       weak_factory_(this) {
   DCHECK(transport_security_state_);
-  crypto_config_.SetDefaults();
   crypto_config_.set_user_agent_id(user_agent_id);
   crypto_config_.AddCanonicalSuffix(".c.youtube.com");
   crypto_config_.AddCanonicalSuffix(".googlevideo.com");
@@ -902,6 +902,7 @@
   config.SetInitialCongestionWindowToSend(
       server_id.is_https() ? kServerSecureInitialCongestionWindow
                            : kServerInecureInitialCongestionWindow);
+  config.set_max_undecryptable_packets(kMaxUndecryptablePackets);
   config.SetInitialFlowControlWindowToSend(kInitialReceiveWindowSize);
   config.SetInitialStreamFlowControlWindowToSend(kInitialReceiveWindowSize);
   config.SetInitialSessionFlowControlWindowToSend(kInitialReceiveWindowSize);
diff --git a/net/quic/quic_stream_factory.h b/net/quic/quic_stream_factory.h
index f4aa77e..f962699 100644
--- a/net/quic/quic_stream_factory.h
+++ b/net/quic/quic_stream_factory.h
@@ -147,13 +147,13 @@
 
   // Until the servers support roaming, close all connections when the local
   // IP address changes.
-  virtual void OnIPAddressChanged() OVERRIDE;
+  virtual void OnIPAddressChanged() override;
 
   // CertDatabase::Observer methods:
 
   // We close all sessions when certificate database is changed.
-  virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE;
-  virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE;
+  virtual void OnCertAdded(const X509Certificate* cert) override;
+  virtual void OnCACertChanged(const X509Certificate* cert) override;
 
   bool require_confirmation() const {
     return require_confirmation_;
diff --git a/net/quic/quic_stream_sequencer_test.cc b/net/quic/quic_stream_sequencer_test.cc
index c553fe5..8c90c9f 100644
--- a/net/quic/quic_stream_sequencer_test.cc
+++ b/net/quic/quic_stream_sequencer_test.cc
@@ -44,7 +44,7 @@
                                                 const string& details));
   MOCK_METHOD1(Reset, void(QuicRstStreamErrorCode error));
   MOCK_METHOD0(OnCanWrite, void());
-  virtual QuicPriority EffectivePriority() const OVERRIDE {
+  virtual QuicPriority EffectivePriority() const override {
     return QuicUtils::HighestPriority();
   }
   virtual bool IsFlowControlEnabled() const {
diff --git a/net/quic/quic_time_wait_list_manager.cc b/net/quic/quic_time_wait_list_manager.cc
index d1f3419..4e069d5 100644
--- a/net/quic/quic_time_wait_list_manager.cc
+++ b/net/quic/quic_time_wait_list_manager.cc
@@ -41,7 +41,7 @@
       QuicTimeWaitListManager* time_wait_list_manager)
       : time_wait_list_manager_(time_wait_list_manager) {}
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     time_wait_list_manager_->CleanUpOldConnectionIds();
     // Let the time wait manager register the alarm at appropriate time.
     return QuicTime::Zero();
diff --git a/net/quic/quic_time_wait_list_manager.h b/net/quic/quic_time_wait_list_manager.h
index 4d7b0c5..13544b7 100644
--- a/net/quic/quic_time_wait_list_manager.h
+++ b/net/quic/quic_time_wait_list_manager.h
@@ -79,7 +79,7 @@
   // Called by the dispatcher when the underlying socket becomes writable again,
   // since we might need to send pending public reset packets which we didn't
   // send because the underlying socket was write blocked.
-  virtual void OnCanWrite() OVERRIDE;
+  virtual void OnCanWrite() override;
 
   // Used to delete connection_id entries that have outlived their time wait
   // period.
diff --git a/net/quic/reliable_quic_stream.cc b/net/quic/reliable_quic_stream.cc
index a10b0ab..a65203b 100644
--- a/net/quic/reliable_quic_stream.cc
+++ b/net/quic/reliable_quic_stream.cc
@@ -81,7 +81,7 @@
                                  int num_retransmitted_packets,
                                  int num_retransmitted_bytes,
                                  QuicTime::Delta delta_largest_observed)
-      OVERRIDE {
+      override {
     DCHECK_LT(0, pending_acks_);
     --pending_acks_;
     num_original_packets_ += num_original_packets;
@@ -106,7 +106,7 @@
 
  protected:
   // Delegates are ref counted.
-  virtual ~ProxyAckNotifierDelegate() OVERRIDE {
+  virtual ~ProxyAckNotifierDelegate() override {
   }
 
  private:
@@ -479,7 +479,6 @@
     DLOG(DFATAL) << "Flow control not enabled! " << version();
     return;
   }
-
   if (flow_controller_.UpdateSendWindowOffset(frame.byte_offset)) {
     // We can write again!
     // TODO(rjshade): This does not respect priorities (e.g. multiple
@@ -533,6 +532,12 @@
   }
 }
 
+void ReliableQuicStream::UpdateSendWindowOffset(uint64 new_window) {
+  if (flow_controller_.UpdateSendWindowOffset(new_window)) {
+    OnCanWrite();
+  }
+}
+
 bool ReliableQuicStream::IsFlowControlBlocked() {
   if (flow_controller_.IsBlocked()) {
     return true;
diff --git a/net/quic/reliable_quic_stream.h b/net/quic/reliable_quic_stream.h
index 5b5ae0f..24bc349 100644
--- a/net/quic/reliable_quic_stream.h
+++ b/net/quic/reliable_quic_stream.h
@@ -111,6 +111,10 @@
   // WINDOW_UPDATE frame.
   void AddBytesConsumed(uint64 bytes);
 
+  // Updates the flow controller's send window offset and calls OnCanWrite if
+  // it was blocked before.
+  void UpdateSendWindowOffset(uint64 new_offset);
+
   // Returns true if the stream is flow control blocked, by the stream flow
   // control window or the connection flow control window.
   bool IsFlowControlBlocked();
@@ -123,6 +127,9 @@
     return fin_received_ || rst_received_;
   }
 
+  // Returns true if the stream has queued data waiting to write.
+  bool HasBufferedData() const;
+
  protected:
   // Sends as much of 'data' to the connection as the connection will consume,
   // and then buffers any remaining data in queued_data_.
@@ -151,8 +158,6 @@
   // Close the write side of the socket.  Further writes will fail.
   void CloseWriteSide();
 
-  bool HasBufferedData() const;
-
   bool fin_buffered() const { return fin_buffered_; }
 
   const QuicSession* session() const { return session_; }
diff --git a/net/quic/reliable_quic_stream_test.cc b/net/quic/reliable_quic_stream_test.cc
index 336ea53..713d0e3 100644
--- a/net/quic/reliable_quic_stream_test.cc
+++ b/net/quic/reliable_quic_stream_test.cc
@@ -48,14 +48,14 @@
       : ReliableQuicStream(id, session),
         should_process_data_(should_process_data) {}
 
-  virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE {
+  virtual uint32 ProcessRawData(const char* data, uint32 data_len) override {
     EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
-  virtual QuicPriority EffectivePriority() const OVERRIDE {
+  virtual QuicPriority EffectivePriority() const override {
     return QuicUtils::HighestPriority();
   }
 
diff --git a/net/quic/test_tools/crypto_test_utils.cc b/net/quic/test_tools/crypto_test_utils.cc
index cf8df9a..9f4dc8b 100644
--- a/net/quic/test_tools/crypto_test_utils.cc
+++ b/net/quic/test_tools/crypto_test_utils.cc
@@ -41,10 +41,10 @@
       : error_(false) {
   }
 
-  virtual void OnError(CryptoFramer* framer) OVERRIDE { error_ = true; }
+  virtual void OnError(CryptoFramer* framer) override { error_ = true; }
 
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE {
+      const CryptoHandshakeMessage& message) override {
     messages_.push_back(message);
   }
 
@@ -143,7 +143,7 @@
   virtual QuicAsyncStatus GetChannelIDKey(
       const string& hostname,
       scoped_ptr<ChannelIDKey>* channel_id_key,
-      ChannelIDSourceCallback* callback) OVERRIDE {
+      ChannelIDSourceCallback* callback) override {
     // Synchronous mode.
     if (!callback) {
       return sync_source_->GetChannelIDKey(hostname, channel_id_key, nullptr);
@@ -160,7 +160,7 @@
   }
 
   // CallbackSource implementation.
-  virtual void RunPendingCallbacks() OVERRIDE {
+  virtual void RunPendingCallbacks() override {
     if (callback_.get()) {
       callback_->Run(&channel_id_key_);
       callback_.reset();
@@ -219,8 +219,6 @@
   TestClientSession client_session(client_conn, DefaultQuicConfig());
   QuicCryptoClientConfig crypto_config;
 
-  client_session.config()->SetDefaults();
-  crypto_config.SetDefaults();
   if (!options.dont_verify_certs) {
     // TODO(wtc): replace this with ProofVerifierForTesting() when we have
     // a working ProofSourceForTesting().
@@ -273,7 +271,6 @@
     QuicRandom* rand,
     QuicConfig* config,
     QuicCryptoServerConfig* crypto_config) {
-  config->SetDefaults();
   QuicCryptoServerConfig::ConfigOptions options;
   options.channel_id_enabled = true;
   scoped_ptr<CryptoHandshakeMessage> scfg(
@@ -356,12 +353,12 @@
         index_(index) {
   }
 
-  virtual StringPiece GetCommonHashes() const OVERRIDE {
+  virtual StringPiece GetCommonHashes() const override {
     CHECK(false) << "not implemented";
     return StringPiece();
   }
 
-  virtual StringPiece GetCert(uint64 hash, uint32 index) const OVERRIDE {
+  virtual StringPiece GetCert(uint64 hash, uint32 index) const override {
     if (hash == hash_ && index == index_) {
       return cert_;
     }
@@ -371,7 +368,7 @@
   virtual bool MatchCert(StringPiece cert,
                          StringPiece common_set_hashes,
                          uint64* out_hash,
-                         uint32* out_index) const OVERRIDE {
+                         uint32* out_index) const override {
     if (cert != cert_) {
       return false;
     }
diff --git a/net/quic/test_tools/crypto_test_utils_chromium.cc b/net/quic/test_tools/crypto_test_utils_chromium.cc
index e475e56..d5edc6c 100644
--- a/net/quic/test_tools/crypto_test_utils_chromium.cc
+++ b/net/quic/test_tools/crypto_test_utils_chromium.cc
@@ -59,7 +59,7 @@
                         const std::string& server_config,
                         bool ecdsa_ok,
                         const std::vector<std::string>** out_certs,
-                        std::string* out_signature) OVERRIDE {
+                        std::string* out_signature) override {
     *out_certs = &certs_;
     *out_signature = kSignature;
     return true;
@@ -84,7 +84,7 @@
       const ProofVerifyContext* verify_context,
       std::string* error_details,
       scoped_ptr<ProofVerifyDetails>* verify_details,
-      ProofVerifierCallback* callback) OVERRIDE {
+      ProofVerifierCallback* callback) override {
     error_details->clear();
     scoped_ptr<ProofVerifyDetailsChromium> verify_details_chromium(
         new ProofVerifyDetailsChromium);
diff --git a/net/quic/test_tools/crypto_test_utils_nss.cc b/net/quic/test_tools/crypto_test_utils_nss.cc
index eaf0ecd..96fdd31 100644
--- a/net/quic/test_tools/crypto_test_utils_nss.cc
+++ b/net/quic/test_tools/crypto_test_utils_nss.cc
@@ -29,7 +29,7 @@
   virtual QuicAsyncStatus GetChannelIDKey(
       const string& hostname,
       scoped_ptr<ChannelIDKey>* channel_id_key,
-      ChannelIDSourceCallback* /*callback*/) OVERRIDE {
+      ChannelIDSourceCallback* /*callback*/) override {
     channel_id_key->reset(new ChannelIDKeyChromium(HostnameToKey(hostname)));
     return QUIC_SUCCESS;
   }
diff --git a/net/quic/test_tools/crypto_test_utils_openssl.cc b/net/quic/test_tools/crypto_test_utils_openssl.cc
index 15babd4..4db57b5 100644
--- a/net/quic/test_tools/crypto_test_utils_openssl.cc
+++ b/net/quic/test_tools/crypto_test_utils_openssl.cc
@@ -26,12 +26,12 @@
 class TestChannelIDKey : public ChannelIDKey {
  public:
   explicit TestChannelIDKey(EVP_PKEY* ecdsa_key) : ecdsa_key_(ecdsa_key) {}
-  virtual ~TestChannelIDKey() OVERRIDE {}
+  virtual ~TestChannelIDKey() override {}
 
   // ChannelIDKey implementation.
 
   virtual bool Sign(StringPiece signed_data,
-                    string* out_signature) const OVERRIDE {
+                    string* out_signature) const override {
     crypto::ScopedEVP_MD_CTX md_ctx(EVP_MD_CTX_create());
     if (!md_ctx ||
         EVP_DigestSignInit(md_ctx.get(), nullptr, EVP_sha256(), nullptr,
@@ -75,7 +75,7 @@
     return true;
   }
 
-  virtual string SerializeKey() const OVERRIDE {
+  virtual string SerializeKey() const override {
     // i2d_PublicKey will produce an ANSI X9.62 public key which, for a P-256
     // key, is 0x04 (meaning uncompressed) followed by the x and y field
     // elements as 32-byte, big-endian numbers.
@@ -106,7 +106,7 @@
   virtual QuicAsyncStatus GetChannelIDKey(
       const string& hostname,
       scoped_ptr<ChannelIDKey>* channel_id_key,
-      ChannelIDSourceCallback* /*callback*/) OVERRIDE {
+      ChannelIDSourceCallback* /*callback*/) override {
     channel_id_key->reset(new TestChannelIDKey(HostnameToKey(hostname)));
     return QUIC_SUCCESS;
   }
diff --git a/net/quic/test_tools/delayed_verify_strike_register_client.h b/net/quic/test_tools/delayed_verify_strike_register_client.h
index 6ae7ba1..479647b 100644
--- a/net/quic/test_tools/delayed_verify_strike_register_client.h
+++ b/net/quic/test_tools/delayed_verify_strike_register_client.h
@@ -27,7 +27,7 @@
 
   virtual void VerifyNonceIsValidAndUnique(base::StringPiece nonce,
                                            QuicWallTime now,
-                                           ResultCallback* cb) OVERRIDE;
+                                           ResultCallback* cb) override;
 
   // Start queueing verifications instead of executing them immediately.
   void StartDelayingVerification() {
diff --git a/net/quic/test_tools/mock_clock.h b/net/quic/test_tools/mock_clock.h
index d6e490f..4a2a28c 100644
--- a/net/quic/test_tools/mock_clock.h
+++ b/net/quic/test_tools/mock_clock.h
@@ -20,11 +20,11 @@
 
   void AdvanceTime(QuicTime::Delta delta);
 
-  virtual QuicTime Now() const OVERRIDE;
+  virtual QuicTime Now() const override;
 
-  virtual QuicTime ApproximateNow() const OVERRIDE;
+  virtual QuicTime ApproximateNow() const override;
 
-  virtual QuicWallTime WallNow() const OVERRIDE;
+  virtual QuicWallTime WallNow() const override;
 
   base::TimeTicks NowInTicks() const;
 
diff --git a/net/quic/test_tools/mock_crypto_client_stream.h b/net/quic/test_tools/mock_crypto_client_stream.h
index e940a1e..10803e8 100644
--- a/net/quic/test_tools/mock_crypto_client_stream.h
+++ b/net/quic/test_tools/mock_crypto_client_stream.h
@@ -46,10 +46,10 @@
 
   // CryptoFramerVisitorInterface implementation.
   virtual void OnHandshakeMessage(
-      const CryptoHandshakeMessage& message) OVERRIDE;
+      const CryptoHandshakeMessage& message) override;
 
   // QuicCryptoClientStream implementation.
-  virtual bool CryptoConnect() OVERRIDE;
+  virtual bool CryptoConnect() override;
 
   // Invokes the sessions's CryptoHandshakeEvent method with the specified
   // event.
diff --git a/net/quic/test_tools/mock_crypto_client_stream_factory.h b/net/quic/test_tools/mock_crypto_client_stream_factory.h
index 721ec25..5add188 100644
--- a/net/quic/test_tools/mock_crypto_client_stream_factory.h
+++ b/net/quic/test_tools/mock_crypto_client_stream_factory.h
@@ -23,7 +23,7 @@
   virtual QuicCryptoClientStream* CreateQuicCryptoClientStream(
       const QuicServerId& server_id,
       QuicClientSession* session,
-      QuicCryptoClientConfig* crypto_config) OVERRIDE;
+      QuicCryptoClientConfig* crypto_config) override;
 
   void set_handshake_mode(
       MockCryptoClientStream::HandshakeMode handshake_mode) {
diff --git a/net/quic/test_tools/mock_random.h b/net/quic/test_tools/mock_random.h
index 53b24b7..b04f170 100644
--- a/net/quic/test_tools/mock_random.h
+++ b/net/quic/test_tools/mock_random.h
@@ -18,12 +18,12 @@
 
   // QuicRandom:
   // Fills the |data| buffer with a repeating byte, initially 'r'.
-  virtual void RandBytes(void* data, size_t len) OVERRIDE;
+  virtual void RandBytes(void* data, size_t len) override;
   // Returns base + the current increment.
-  virtual uint64 RandUint64() OVERRIDE;
+  virtual uint64 RandUint64() override;
   // Does nothing.
   virtual void Reseed(const void* additional_entropy,
-                      size_t entropy_len) OVERRIDE;
+                      size_t entropy_len) override;
 
   // ChangeValue increments |increment_|. This causes the value returned by
   // |RandUint64| and the byte that |RandBytes| fills with, to change.
diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index 0cf13e1..6cdd02a 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -37,8 +37,8 @@
       : QuicAlarm(delegate) {
   }
 
-  virtual void SetImpl() OVERRIDE {}
-  virtual void CancelImpl() OVERRIDE {}
+  virtual void SetImpl() override {}
+  virtual void CancelImpl() override {}
 };
 
 }  // namespace
@@ -229,7 +229,7 @@
   virtual ~NiceMockPacketWriterFactory() {}
 
   virtual QuicPacketWriter* Create(
-      QuicConnection* /*connection*/) const OVERRIDE {
+      QuicConnection* /*connection*/) const override {
     return new testing::NiceMock<MockPacketWriter>();
   }
 
@@ -609,7 +609,6 @@
 
 QuicConfig DefaultQuicConfig() {
   QuicConfig config;
-  config.SetDefaults();
   config.SetInitialFlowControlWindowToSend(
       kInitialSessionFlowControlWindowForTest);
   config.SetInitialStreamFlowControlWindowToSend(
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index 4c57a9b..f009641 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -190,35 +190,35 @@
  public:
   NoOpFramerVisitor() {}
 
-  virtual void OnError(QuicFramer* framer) OVERRIDE {}
-  virtual void OnPacket() OVERRIDE {}
+  virtual void OnError(QuicFramer* framer) override {}
+  virtual void OnPacket() override {}
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE {}
+      const QuicPublicResetPacket& packet) override {}
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE {}
-  virtual void OnRevivedPacket() OVERRIDE {}
-  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE;
-  virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) OVERRIDE;
+      const QuicVersionNegotiationPacket& packet) override {}
+  virtual void OnRevivedPacket() override {}
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) override;
+  virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
   virtual bool OnUnauthenticatedPublicHeader(
-      const QuicPacketPublicHeader& header) OVERRIDE;
-  virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {}
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
-  virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE {}
-  virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
-  virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
+      const QuicPacketPublicHeader& header) override;
+  virtual void OnDecryptedPacket(EncryptionLevel level) override {}
+  virtual bool OnPacketHeader(const QuicPacketHeader& header) override;
+  virtual void OnFecProtectedPayload(base::StringPiece payload) override {}
+  virtual bool OnStreamFrame(const QuicStreamFrame& frame) override;
+  virtual bool OnAckFrame(const QuicAckFrame& frame) override;
   virtual bool OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE;
+      const QuicCongestionFeedbackFrame& frame) override;
   virtual bool OnStopWaitingFrame(
-      const QuicStopWaitingFrame& frame) OVERRIDE;
-  virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE;
-  virtual void OnFecData(const QuicFecData& fec) OVERRIDE {}
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
+      const QuicStopWaitingFrame& frame) override;
+  virtual bool OnPingFrame(const QuicPingFrame& frame) override;
+  virtual void OnFecData(const QuicFecData& fec) override {}
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
   virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) OVERRIDE;
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
-  virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) OVERRIDE;
-  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE;
-  virtual void OnPacketComplete() OVERRIDE {}
+      const QuicConnectionCloseFrame& frame) override;
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
+  virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
+  virtual void OnPacketComplete() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOpFramerVisitor);
@@ -255,9 +255,9 @@
  public:
   MockHelper();
   virtual ~MockHelper();
-  virtual const QuicClock* GetClock() const OVERRIDE;
-  virtual QuicRandom* GetRandomGenerator() OVERRIDE;
-  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE;
+  virtual const QuicClock* GetClock() const override;
+  virtual QuicRandom* GetRandomGenerator() override;
+  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
   void AdvanceTime(QuicTime::Delta delta);
 
  private:
@@ -312,7 +312,7 @@
     QuicConnection::ProcessUdpPacket(self_address, peer_address, packet);
   }
 
-  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) override {
     return false;
   }
 
@@ -331,7 +331,7 @@
 
   virtual ~PacketSavingConnection();
 
-  virtual void SendOrQueuePacket(QueuedPacket packet) OVERRIDE;
+  virtual void SendOrQueuePacket(QueuedPacket packet) override;
 
   std::vector<QuicPacket*> packets_;
   std::vector<QuicEncryptedPacket*> encrypted_packets_;
@@ -383,7 +383,7 @@
 
   void SetCryptoStream(QuicCryptoStream* stream);
 
-  virtual QuicCryptoStream* GetCryptoStream() OVERRIDE;
+  virtual QuicCryptoStream* GetCryptoStream() override;
 
  private:
   QuicCryptoStream* crypto_stream_;
@@ -408,7 +408,7 @@
 
   void SetCryptoStream(QuicCryptoStream* stream);
 
-  virtual QuicCryptoStream* GetCryptoStream() OVERRIDE;
+  virtual QuicCryptoStream* GetCryptoStream() override;
 
  private:
   QuicCryptoStream* crypto_stream_;
@@ -496,7 +496,7 @@
   virtual ~TestEntropyCalculator();
 
   virtual QuicPacketEntropyHash EntropyHash(
-      QuicPacketSequenceNumber sequence_number) const OVERRIDE;
+      QuicPacketSequenceNumber sequence_number) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestEntropyCalculator);
@@ -554,7 +554,7 @@
   virtual ~TestWriterFactory();
 
   virtual QuicPacketWriter* Create(QuicServerPacketWriter* writer,
-                                   QuicConnection* connection) OVERRIDE;
+                                   QuicConnection* connection) override;
 
   // Calls OnPacketSent on the last QuicConnection to write through one of the
   // packet writers created by this factory.
@@ -572,7 +572,7 @@
         const char* buffer,
         size_t buf_len,
         const IPAddressNumber& self_address,
-        const IPEndPoint& peer_address) OVERRIDE;
+        const IPEndPoint& peer_address) override;
 
    private:
     TestWriterFactory* factory_;
diff --git a/net/quic/test_tools/simple_quic_framer.cc b/net/quic/test_tools/simple_quic_framer.cc
index a08d555..6999cf5 100644
--- a/net/quic/test_tools/simple_quic_framer.cc
+++ b/net/quic/test_tools/simple_quic_framer.cc
@@ -22,48 +22,48 @@
       : error_(QUIC_NO_ERROR) {
   }
 
-  virtual ~SimpleFramerVisitor() OVERRIDE {
+  virtual ~SimpleFramerVisitor() override {
     STLDeleteElements(&stream_data_);
   }
 
-  virtual void OnError(QuicFramer* framer) OVERRIDE {
+  virtual void OnError(QuicFramer* framer) override {
     error_ = framer->error();
   }
 
-  virtual bool OnProtocolVersionMismatch(QuicVersion version) OVERRIDE {
+  virtual bool OnProtocolVersionMismatch(QuicVersion version) override {
     return false;
   }
 
-  virtual void OnPacket() OVERRIDE {}
+  virtual void OnPacket() override {}
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& packet) OVERRIDE {
+      const QuicPublicResetPacket& packet) override {
     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
   }
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& packet) OVERRIDE {
+      const QuicVersionNegotiationPacket& packet) override {
     version_negotiation_packet_.reset(
         new QuicVersionNegotiationPacket(packet));
   }
-  virtual void OnRevivedPacket() OVERRIDE {}
+  virtual void OnRevivedPacket() override {}
 
   virtual bool OnUnauthenticatedPublicHeader(
-      const QuicPacketPublicHeader& header) OVERRIDE {
+      const QuicPacketPublicHeader& header) override {
     return true;
   }
   virtual bool OnUnauthenticatedHeader(
-      const QuicPacketHeader& header) OVERRIDE {
+      const QuicPacketHeader& header) override {
     return true;
   }
-  virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {}
-  virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
+  virtual void OnDecryptedPacket(EncryptionLevel level) override {}
+  virtual bool OnPacketHeader(const QuicPacketHeader& header) override {
     has_header_ = true;
     header_ = header;
     return true;
   }
 
-  virtual void OnFecProtectedPayload(StringPiece payload) OVERRIDE {}
+  virtual void OnFecProtectedPayload(StringPiece payload) override {}
 
-  virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
+  virtual bool OnStreamFrame(const QuicStreamFrame& frame) override {
     // Save a copy of the data so it is valid after the packet is processed.
     stream_data_.push_back(frame.GetDataAsString());
     QuicStreamFrame stream_frame(frame);
@@ -75,61 +75,61 @@
     return true;
   }
 
-  virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE {
+  virtual bool OnAckFrame(const QuicAckFrame& frame) override {
     ack_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) OVERRIDE {
+      const QuicCongestionFeedbackFrame& frame) override {
     feedback_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) OVERRIDE {
+  virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
     stop_waiting_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnPingFrame(const QuicPingFrame& frame) OVERRIDE {
+  virtual bool OnPingFrame(const QuicPingFrame& frame) override {
     ping_frames_.push_back(frame);
     return true;
   }
 
-  virtual void OnFecData(const QuicFecData& fec) OVERRIDE {
+  virtual void OnFecData(const QuicFecData& fec) override {
     fec_data_ = fec;
     fec_redundancy_ = fec_data_.redundancy.as_string();
     fec_data_.redundancy = fec_redundancy_;
   }
 
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE {
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
     rst_stream_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame& frame) OVERRIDE {
+      const QuicConnectionCloseFrame& frame) override {
     connection_close_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE {
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override {
     goaway_frames_.push_back(frame);
     return true;
   }
 
   virtual bool OnWindowUpdateFrame(
-      const QuicWindowUpdateFrame& frame) OVERRIDE {
+      const QuicWindowUpdateFrame& frame) override {
     window_update_frames_.push_back(frame);
     return true;
   }
 
-  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
+  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
     blocked_frames_.push_back(frame);
     return true;
   }
 
-  virtual void OnPacketComplete() OVERRIDE {}
+  virtual void OnPacketComplete() override {}
 
   const QuicPacketHeader& header() const { return header_; }
   const vector<QuicAckFrame>& ack_frames() const { return ack_frames_; }
diff --git a/net/quic/test_tools/test_task_runner.h b/net/quic/test_tools/test_task_runner.h
index e25bf2a..ea6793f 100644
--- a/net/quic/test_tools/test_task_runner.h
+++ b/net/quic/test_tools/test_task_runner.h
@@ -28,8 +28,8 @@
   // base::TaskRunner implementation.
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const base::Closure& task,
-                               base::TimeDelta delay) OVERRIDE;
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
+                               base::TimeDelta delay) override;
+  virtual bool RunsTasksOnCurrentThread() const override;
 
   const std::vector<PostedTask>& GetPostedTasks() const;
 
diff --git a/net/server/http_server_unittest.cc b/net/server/http_server_unittest.cc
index 216cb03..be0e271 100644
--- a/net/server/http_server_unittest.cc
+++ b/net/server/http_server_unittest.cc
@@ -181,7 +181,7 @@
  public:
   HttpServerTest() : quit_after_request_count_(0) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     scoped_ptr<ServerSocket> server_socket(
         new TCPServerSocket(NULL, net::NetLog::Source()));
     server_socket->ListenWithAddressAndPort("127.0.0.1", 0, 1);
@@ -189,26 +189,26 @@
     ASSERT_EQ(OK, server_->GetLocalAddress(&server_address_));
   }
 
-  virtual void OnConnect(int connection_id) OVERRIDE {}
+  virtual void OnConnect(int connection_id) override {}
 
   virtual void OnHttpRequest(int connection_id,
-                             const HttpServerRequestInfo& info) OVERRIDE {
+                             const HttpServerRequestInfo& info) override {
     requests_.push_back(std::make_pair(info, connection_id));
     if (requests_.size() == quit_after_request_count_)
       run_loop_quit_func_.Run();
   }
 
   virtual void OnWebSocketRequest(int connection_id,
-                                  const HttpServerRequestInfo& info) OVERRIDE {
+                                  const HttpServerRequestInfo& info) override {
     NOTREACHED();
   }
 
   virtual void OnWebSocketMessage(int connection_id,
-                                  const std::string& data) OVERRIDE {
+                                  const std::string& data) override {
     NOTREACHED();
   }
 
-  virtual void OnClose(int connection_id) OVERRIDE {}
+  virtual void OnClose(int connection_id) override {}
 
   bool RunUntilRequestsReceived(size_t count) {
     quit_after_request_count_ = count;
@@ -249,17 +249,17 @@
 
 class WebSocketTest : public HttpServerTest {
   virtual void OnHttpRequest(int connection_id,
-                             const HttpServerRequestInfo& info) OVERRIDE {
+                             const HttpServerRequestInfo& info) override {
     NOTREACHED();
   }
 
   virtual void OnWebSocketRequest(int connection_id,
-                                  const HttpServerRequestInfo& info) OVERRIDE {
+                                  const HttpServerRequestInfo& info) override {
     HttpServerTest::OnHttpRequest(connection_id, info);
   }
 
   virtual void OnWebSocketMessage(int connection_id,
-                                  const std::string& data) OVERRIDE {
+                                  const std::string& data) override {
   }
 };
 
@@ -409,7 +409,7 @@
         : quit_loop_func_(quit_loop_func) {}
     virtual ~TestURLFetcherDelegate() {}
 
-    virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE {
+    virtual void OnURLFetchComplete(const URLFetcher* source) override {
       EXPECT_EQ(HTTP_INTERNAL_SERVER_ERROR, source->GetResponseCode());
       quit_loop_func_.Run();
     }
@@ -473,10 +473,10 @@
         read_buf_len_(0) {}
 
   // StreamSocket
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual void Disconnect() OVERRIDE {
+  virtual void Disconnect() override {
     connected_ = false;
     if (!read_callback_.is_null()) {
       read_buf_ = NULL;
@@ -484,28 +484,28 @@
       base::ResetAndReturn(&read_callback_).Run(ERR_CONNECTION_CLOSED);
     }
   }
-  virtual bool IsConnected() const OVERRIDE { return connected_; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return IsConnected(); }
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual bool IsConnected() const override { return connected_; }
+  virtual bool IsConnectedAndIdle() const override { return IsConnected(); }
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE { return true; }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual const BoundNetLog& NetLog() const override { return net_log_; }
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override { return true; }
+  virtual bool UsingTCPFastOpen() const override { return false; }
+  virtual bool WasNpnNegotiated() const override { return false; }
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     if (!connected_) {
       return ERR_SOCKET_NOT_CONNECTED;
     }
@@ -523,13 +523,13 @@
     return read_len;
   }
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
+  virtual int SetReceiveBufferSize(int32 size) override {
     return ERR_NOT_IMPLEMENTED;
   }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE {
+  virtual int SetSendBufferSize(int32 size) override {
     return ERR_NOT_IMPLEMENTED;
   }
 
@@ -621,7 +621,7 @@
 
 class CloseOnConnectHttpServerTest : public HttpServerTest {
  public:
-  virtual void OnConnect(int connection_id) OVERRIDE {
+  virtual void OnConnect(int connection_id) override {
     connection_ids_.push_back(connection_id);
     server_->Close(connection_id);
   }
diff --git a/net/server/web_socket.cc b/net/server/web_socket.cc
index ec0fdac..118cdf8 100644
--- a/net/server/web_socket.cc
+++ b/net/server/web_socket.cc
@@ -54,7 +54,7 @@
     return new WebSocketHixie76(server, connection, request, pos);
   }
 
-  virtual void Accept(const HttpServerRequestInfo& request) OVERRIDE {
+  virtual void Accept(const HttpServerRequestInfo& request) override {
     std::string key1 = request.GetHeaderValue("sec-websocket-key1");
     std::string key2 = request.GetHeaderValue("sec-websocket-key2");
 
@@ -86,7 +86,7 @@
                      std::string(reinterpret_cast<char*>(digest.a), 16));
   }
 
-  virtual ParseResult Read(std::string* message) OVERRIDE {
+  virtual ParseResult Read(std::string* message) override {
     DCHECK(message);
     HttpConnection::ReadIOBuffer* read_buf = connection_->read_buf();
     if (read_buf->StartOfBuffer()[0])
@@ -103,7 +103,7 @@
     return FRAME_OK;
   }
 
-  virtual void Send(const std::string& message) OVERRIDE {
+  virtual void Send(const std::string& message) override {
     char message_start = 0;
     char message_end = -1;
     server_->SendRaw(connection_->id(), std::string(1, message_start));
@@ -199,7 +199,7 @@
     return new WebSocketHybi17(server, connection, request, pos);
   }
 
-  virtual void Accept(const HttpServerRequestInfo& request) OVERRIDE {
+  virtual void Accept(const HttpServerRequestInfo& request) override {
     static const char* const kWebSocketGuid =
         "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
     std::string key = request.GetHeaderValue("sec-websocket-key");
@@ -217,7 +217,7 @@
                            encoded_hash.c_str()));
   }
 
-  virtual ParseResult Read(std::string* message) OVERRIDE {
+  virtual ParseResult Read(std::string* message) override {
     HttpConnection::ReadIOBuffer* read_buf = connection_->read_buf();
     base::StringPiece frame(read_buf->StartOfBuffer(), read_buf->GetSize());
     int bytes_consumed = 0;
@@ -230,7 +230,7 @@
     return result;
   }
 
-  virtual void Send(const std::string& message) OVERRIDE {
+  virtual void Send(const std::string& message) override {
     if (closed_)
       return;
     server_->SendRaw(connection_->id(),
diff --git a/net/socket/client_socket_factory.cc b/net/socket/client_socket_factory.cc
index 9539145..f372aff 100644
--- a/net/socket/client_socket_factory.cc
+++ b/net/socket/client_socket_factory.cc
@@ -56,11 +56,11 @@
     CertDatabase::GetInstance()->RemoveObserver(this);
   }
 
-  virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE {
+  virtual void OnCertAdded(const X509Certificate* cert) override {
     ClearSSLSessionCache();
   }
 
-  virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE {
+  virtual void OnCACertChanged(const X509Certificate* cert) override {
     // Per wtc, we actually only need to flush when trust is reduced.
     // Always flush now because OnCACertChanged does not tell us this.
     // See comments in ClientSocketPoolManager::OnCACertChanged.
@@ -71,7 +71,7 @@
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE {
+      const NetLog::Source& source) override {
     return scoped_ptr<DatagramClientSocket>(
         new UDPClientSocket(bind_type, rand_int_cb, net_log, source));
   }
@@ -79,7 +79,7 @@
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE {
+      const NetLog::Source& source) override {
     return scoped_ptr<StreamSocket>(
         new TCPClientSocket(addresses, net_log, source));
   }
@@ -88,7 +88,7 @@
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE {
+      const SSLClientSocketContext& context) override {
     // nss_thread_task_runner_ may be NULL if g_use_dedicated_nss_thread is
     // false or if the dedicated NSS thread failed to start. If so, cause NSS
     // functions to execute on the current task runner.
@@ -120,7 +120,7 @@
 #endif
   }
 
-  virtual void ClearSSLSessionCache() OVERRIDE {
+  virtual void ClearSSLSessionCache() override {
     SSLClientSocket::ClearSessionCache();
   }
 
diff --git a/net/socket/client_socket_pool.cc b/net/socket/client_socket_pool.cc
index 0eebd11..261e87f 100644
--- a/net/socket/client_socket_pool.cc
+++ b/net/socket/client_socket_pool.cc
@@ -12,10 +12,10 @@
 // alive.
 // TODO(ziadh): Change this timeout after getting histogram data on how long it
 // should be.
-int g_unused_idle_socket_timeout_s = 10;
+int64 g_unused_idle_socket_timeout_s = 10;
 
 // The maximum duration, in seconds, to keep used idle persistent sockets alive.
-int g_used_idle_socket_timeout_s = 300;  // 5 minutes
+int64 g_used_idle_socket_timeout_s = 300;  // 5 minutes
 
 }  // namespace
 
diff --git a/net/socket/client_socket_pool_base.h b/net/socket/client_socket_pool_base.h
index 8079cd4..e2fde00 100644
--- a/net/socket/client_socket_pool_base.h
+++ b/net/socket/client_socket_pool_base.h
@@ -327,10 +327,10 @@
   void EnableConnectBackupJobs();
 
   // ConnectJob::Delegate methods:
-  virtual void OnConnectJobComplete(int result, ConnectJob* job) OVERRIDE;
+  virtual void OnConnectJobComplete(int result, ConnectJob* job) override;
 
   // NetworkChangeNotifier::IPAddressObserver methods:
-  virtual void OnIPAddressChanged() OVERRIDE;
+  virtual void OnIPAddressChanged() override;
 
  private:
   friend class base::RefCounted<ClientSocketPoolBaseHelper>;
@@ -856,7 +856,7 @@
     virtual scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const internal::ClientSocketPoolBaseHelper::Request& request,
-        ConnectJob::Delegate* delegate) const OVERRIDE {
+        ConnectJob::Delegate* delegate) const override {
       const Request& casted_request = static_cast<const Request&>(request);
       return connect_job_factory_->NewConnectJob(
           group_name, casted_request, delegate);
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index 5a672b4..3cafc89 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -130,7 +130,7 @@
   // Socket implementation.
   virtual int Read(
       IOBuffer* /* buf */, int len,
-      const CompletionCallback& /* callback */) OVERRIDE {
+      const CompletionCallback& /* callback */) override {
     if (has_unread_data_ && len > 0) {
       has_unread_data_ = false;
       was_used_to_convey_data_ = true;
@@ -141,50 +141,50 @@
 
   virtual int Write(
       IOBuffer* /* buf */, int len,
-      const CompletionCallback& /* callback */) OVERRIDE {
+      const CompletionCallback& /* callback */) override {
     was_used_to_convey_data_ = true;
     return len;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
+  virtual int SetReceiveBufferSize(int32 size) override { return OK; }
+  virtual int SetSendBufferSize(int32 size) override { return OK; }
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     connected_ = true;
     return OK;
   }
 
-  virtual void Disconnect() OVERRIDE { connected_ = false; }
-  virtual bool IsConnected() const OVERRIDE { return connected_; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE {
+  virtual void Disconnect() override { connected_ = false; }
+  virtual bool IsConnected() const override { return connected_; }
+  virtual bool IsConnectedAndIdle() const override {
     return connected_ && !has_unread_data_;
   }
 
-  virtual int GetPeerAddress(IPEndPoint* /* address */) const OVERRIDE {
+  virtual int GetPeerAddress(IPEndPoint* /* address */) const override {
     return ERR_UNEXPECTED;
   }
 
-  virtual int GetLocalAddress(IPEndPoint* /* address */) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* /* address */) const override {
     return ERR_UNEXPECTED;
   }
 
-  virtual const BoundNetLog& NetLog() const OVERRIDE {
+  virtual const BoundNetLog& NetLog() const override {
     return net_log_;
   }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override {
     return was_used_to_convey_data_;
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
-  virtual bool WasNpnNegotiated() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override { return false; }
+  virtual bool WasNpnNegotiated() const override {
     return false;
   }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override {
     return false;
   }
 
@@ -207,7 +207,7 @@
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE {
+      const NetLog::Source& source) override {
     NOTREACHED();
     return scoped_ptr<DatagramClientSocket>();
   }
@@ -215,7 +215,7 @@
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* /* net_log */,
-      const NetLog::Source& /*source*/) OVERRIDE {
+      const NetLog::Source& /*source*/) override {
     allocation_count_++;
     return scoped_ptr<StreamSocket>();
   }
@@ -224,12 +224,12 @@
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE {
+      const SSLClientSocketContext& context) override {
     NOTIMPLEMENTED();
     return scoped_ptr<SSLClientSocket>();
   }
 
-  virtual void ClearSSLSessionCache() OVERRIDE {
+  virtual void ClearSSLSessionCache() override {
     NOTIMPLEMENTED();
   }
 
@@ -291,9 +291,9 @@
 
   // From ConnectJob:
 
-  virtual LoadState GetLoadState() const OVERRIDE { return load_state_; }
+  virtual LoadState GetLoadState() const override { return load_state_; }
 
-  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) OVERRIDE {
+  virtual void GetAdditionalErrorState(ClientSocketHandle* handle) override {
     if (store_additional_error_state_) {
       // Set all of the additional error state fields in some way.
       handle->set_is_ssl_error(true);
@@ -306,7 +306,7 @@
  private:
   // From ConnectJob:
 
-  virtual int ConnectInternal() OVERRIDE {
+  virtual int ConnectInternal() override {
     AddressList ignored;
     client_socket_factory_->CreateTransportClientSocket(
         ignored, NULL, net::NetLog::Source());
@@ -457,7 +457,7 @@
   virtual scoped_ptr<ConnectJob> NewConnectJob(
       const std::string& group_name,
       const TestClientSocketPoolBase::Request& request,
-      ConnectJob::Delegate* delegate) const OVERRIDE {
+      ConnectJob::Delegate* delegate) const override {
     EXPECT_TRUE(!job_types_ || !job_types_->empty());
     TestConnectJob::JobType job_type = job_type_;
     if (job_types_ && !job_types_->empty()) {
@@ -473,7 +473,7 @@
                                                      net_log_));
   }
 
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
+  virtual base::TimeDelta ConnectionTimeout() const override {
     return timeout_duration_;
   }
 
@@ -510,7 +510,7 @@
       net::RequestPriority priority,
       ClientSocketHandle* handle,
       const CompletionCallback& callback,
-      const BoundNetLog& net_log) OVERRIDE {
+      const BoundNetLog& net_log) override {
     const scoped_refptr<TestSocketParams>* casted_socket_params =
         static_cast<const scoped_refptr<TestSocketParams>*>(params);
     return base_.RequestSocket(group_name, *casted_socket_params, priority,
@@ -520,7 +520,7 @@
   virtual void RequestSockets(const std::string& group_name,
                               const void* params,
                               int num_sockets,
-                              const BoundNetLog& net_log) OVERRIDE {
+                              const BoundNetLog& net_log) override {
     const scoped_refptr<TestSocketParams>* casted_params =
         static_cast<const scoped_refptr<TestSocketParams>*>(params);
 
@@ -529,65 +529,65 @@
 
   virtual void CancelRequest(
       const std::string& group_name,
-      ClientSocketHandle* handle) OVERRIDE {
+      ClientSocketHandle* handle) override {
     base_.CancelRequest(group_name, handle);
   }
 
   virtual void ReleaseSocket(
       const std::string& group_name,
       scoped_ptr<StreamSocket> socket,
-      int id) OVERRIDE {
+      int id) override {
     base_.ReleaseSocket(group_name, socket.Pass(), id);
   }
 
-  virtual void FlushWithError(int error) OVERRIDE {
+  virtual void FlushWithError(int error) override {
     base_.FlushWithError(error);
   }
 
-  virtual bool IsStalled() const OVERRIDE {
+  virtual bool IsStalled() const override {
     return base_.IsStalled();
   }
 
-  virtual void CloseIdleSockets() OVERRIDE {
+  virtual void CloseIdleSockets() override {
     base_.CloseIdleSockets();
   }
 
-  virtual int IdleSocketCount() const OVERRIDE {
+  virtual int IdleSocketCount() const override {
     return base_.idle_socket_count();
   }
 
   virtual int IdleSocketCountInGroup(
-      const std::string& group_name) const OVERRIDE {
+      const std::string& group_name) const override {
     return base_.IdleSocketCountInGroup(group_name);
   }
 
   virtual LoadState GetLoadState(
       const std::string& group_name,
-      const ClientSocketHandle* handle) const OVERRIDE {
+      const ClientSocketHandle* handle) const override {
     return base_.GetLoadState(group_name, handle);
   }
 
-  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE {
+  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override {
     base_.AddHigherLayeredPool(higher_pool);
   }
 
   virtual void RemoveHigherLayeredPool(
-      HigherLayeredPool* higher_pool) OVERRIDE {
+      HigherLayeredPool* higher_pool) override {
     base_.RemoveHigherLayeredPool(higher_pool);
   }
 
   virtual base::DictionaryValue* GetInfoAsValue(
       const std::string& name,
       const std::string& type,
-      bool include_nested_pools) const OVERRIDE {
+      bool include_nested_pools) const override {
     return base_.GetInfoAsValue(name, type);
   }
 
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
+  virtual base::TimeDelta ConnectionTimeout() const override {
     return base_.ConnectionTimeout();
   }
 
-  virtual ClientSocketPoolHistograms* histograms() const OVERRIDE {
+  virtual ClientSocketPoolHistograms* histograms() const override {
     return base_.histograms();
   }
 
@@ -653,7 +653,7 @@
       : have_result_(false), waiting_for_result_(false), result_(OK) {}
   virtual ~TestConnectJobDelegate() {}
 
-  virtual void OnConnectJobComplete(int result, ConnectJob* job) OVERRIDE {
+  virtual void OnConnectJobComplete(int result, ConnectJob* job) override {
     result_ = result;
     scoped_ptr<ConnectJob> owned_job(job);
     scoped_ptr<StreamSocket> socket = owned_job->PassSocket();
diff --git a/net/socket/client_socket_pool_manager_impl.h b/net/socket/client_socket_pool_manager_impl.h
index 22afbfa..94fd55d 100644
--- a/net/socket/client_socket_pool_manager_impl.h
+++ b/net/socket/client_socket_pool_manager_impl.h
@@ -73,29 +73,29 @@
                               HttpNetworkSession::SocketPoolType pool_type);
   virtual ~ClientSocketPoolManagerImpl();
 
-  virtual void FlushSocketPoolsWithError(int error) OVERRIDE;
-  virtual void CloseIdleSockets() OVERRIDE;
+  virtual void FlushSocketPoolsWithError(int error) override;
+  virtual void CloseIdleSockets() override;
 
-  virtual TransportClientSocketPool* GetTransportSocketPool() OVERRIDE;
+  virtual TransportClientSocketPool* GetTransportSocketPool() override;
 
-  virtual SSLClientSocketPool* GetSSLSocketPool() OVERRIDE;
+  virtual SSLClientSocketPool* GetSSLSocketPool() override;
 
   virtual SOCKSClientSocketPool* GetSocketPoolForSOCKSProxy(
-      const HostPortPair& socks_proxy) OVERRIDE;
+      const HostPortPair& socks_proxy) override;
 
   virtual HttpProxyClientSocketPool* GetSocketPoolForHTTPProxy(
-      const HostPortPair& http_proxy) OVERRIDE;
+      const HostPortPair& http_proxy) override;
 
   virtual SSLClientSocketPool* GetSocketPoolForSSLWithProxy(
-      const HostPortPair& proxy_server) OVERRIDE;
+      const HostPortPair& proxy_server) override;
 
   // Creates a Value summary of the state of the socket pools. The caller is
   // responsible for deleting the returned value.
-  virtual base::Value* SocketPoolInfoToValue() const OVERRIDE;
+  virtual base::Value* SocketPoolInfoToValue() const override;
 
   // CertDatabase::Observer methods:
-  virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE;
-  virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE;
+  virtual void OnCertAdded(const X509Certificate* cert) override;
+  virtual void OnCACertChanged(const X509Certificate* cert) override;
 
  private:
   typedef internal::OwnedPoolMap<HostPortPair, TransportClientSocketPool*>
diff --git a/net/socket/mock_client_socket_pool_manager.h b/net/socket/mock_client_socket_pool_manager.h
index c2c3792..03930e3 100644
--- a/net/socket/mock_client_socket_pool_manager.h
+++ b/net/socket/mock_client_socket_pool_manager.h
@@ -27,17 +27,17 @@
                                     SSLClientSocketPool* pool);
 
   // ClientSocketPoolManager methods:
-  virtual void FlushSocketPoolsWithError(int error) OVERRIDE;
-  virtual void CloseIdleSockets() OVERRIDE;
-  virtual TransportClientSocketPool* GetTransportSocketPool() OVERRIDE;
-  virtual SSLClientSocketPool* GetSSLSocketPool() OVERRIDE;
+  virtual void FlushSocketPoolsWithError(int error) override;
+  virtual void CloseIdleSockets() override;
+  virtual TransportClientSocketPool* GetTransportSocketPool() override;
+  virtual SSLClientSocketPool* GetSSLSocketPool() override;
   virtual SOCKSClientSocketPool* GetSocketPoolForSOCKSProxy(
-      const HostPortPair& socks_proxy) OVERRIDE;
+      const HostPortPair& socks_proxy) override;
   virtual HttpProxyClientSocketPool* GetSocketPoolForHTTPProxy(
-      const HostPortPair& http_proxy) OVERRIDE;
+      const HostPortPair& http_proxy) override;
   virtual SSLClientSocketPool* GetSocketPoolForSSLWithProxy(
-      const HostPortPair& proxy_server) OVERRIDE;
-  virtual base::Value* SocketPoolInfoToValue() const OVERRIDE;
+      const HostPortPair& proxy_server) override;
+  virtual base::Value* SocketPoolInfoToValue() const override;
 
  private:
   typedef internal::OwnedPoolMap<HostPortPair, TransportClientSocketPool*>
diff --git a/net/socket/next_proto.h b/net/socket/next_proto.h
index 08e6801..e715aca 100644
--- a/net/socket/next_proto.h
+++ b/net/socket/next_proto.h
@@ -14,8 +14,10 @@
 // Next Protocol Negotiation (NPN), if successful, results in agreement on an
 // application-level string that specifies the application level protocol to
 // use over the TLS connection. NextProto enumerates the application level
-// protocols that we recognise.  Do not change or reuse values, because they
-// are used to collect statistics on UMA.
+// protocols that we recognize.  Do not change or reuse values, because they
+// are used to collect statistics on UMA.  Also, values must be in [0,499),
+// because of the way TLS protocol negotiation extension information is added to
+// UMA histogram.
 enum NextProto {
   kProtoUnknown = 0,
   kProtoHTTP11 = 1,
diff --git a/net/socket/socket_libevent.h b/net/socket/socket_libevent.h
index 5950951..a072738 100644
--- a/net/socket/socket_libevent.h
+++ b/net/socket/socket_libevent.h
@@ -81,8 +81,8 @@
 
  private:
   // base::MessageLoopForIO::Watcher methods.
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
+  virtual void OnFileCanReadWithoutBlocking(int fd) override;
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override;
 
   int DoAccept(scoped_ptr<SocketLibevent>* socket);
   void AcceptCompleted();
diff --git a/net/socket/socket_test_util.h b/net/socket/socket_test_util.h
index 50d28ec..1496aec 100644
--- a/net/socket/socket_test_util.h
+++ b/net/socket/socket_test_util.h
@@ -262,9 +262,9 @@
   virtual void CompleteRead() {}
 
   // SocketDataProvider implementation.
-  virtual MockRead GetNextRead() OVERRIDE;
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  virtual void Reset() OVERRIDE;
+  virtual MockRead GetNextRead() override;
+  virtual MockWriteResult OnWrite(const std::string& data) override;
+  virtual void Reset() override;
 
  private:
   MockRead* reads_;
@@ -292,9 +292,9 @@
   void allow_unconsumed_reads(bool allow) { allow_unconsumed_reads_ = allow; }
 
   // SocketDataProvider implementation.
-  virtual MockRead GetNextRead() OVERRIDE;
+  virtual MockRead GetNextRead() override;
   virtual MockWriteResult OnWrite(const std::string& data) = 0;
-  virtual void Reset() OVERRIDE;
+  virtual void Reset() override;
 
  protected:
   // The next time there is a read from this socket, it will return |data|.
@@ -376,10 +376,10 @@
   void ForceNextRead();
 
   // StaticSocketDataProvider:
-  virtual MockRead GetNextRead() OVERRIDE;
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  virtual void Reset() OVERRIDE;
-  virtual void CompleteRead() OVERRIDE;
+  virtual MockRead GetNextRead() override;
+  virtual MockWriteResult OnWrite(const std::string& data) override;
+  virtual void Reset() override;
+  virtual void CompleteRead() override;
 
  private:
   int write_delay_;
@@ -430,10 +430,10 @@
   void EndLoop();
 
   // StaticSocketDataProvider:
-  virtual MockRead GetNextRead() OVERRIDE;
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  virtual void Reset() OVERRIDE;
-  virtual void CompleteRead() OVERRIDE;
+  virtual MockRead GetNextRead() override;
+  virtual MockWriteResult OnWrite(const std::string& data) override;
+  virtual void Reset() override;
+  virtual void CompleteRead() override;
 
  private:
   int sequence_number_;
@@ -560,14 +560,14 @@
 
   // When the socket calls Read(), that calls GetNextRead(), and expects either
   // ERR_IO_PENDING or data.
-  virtual MockRead GetNextRead() OVERRIDE;
+  virtual MockRead GetNextRead() override;
 
   // When the socket calls Write(), it always completes synchronously. OnWrite()
   // checks to make sure the written data matches the expected data. The
   // callback will not be invoked until its sequence number is reached.
-  virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE;
-  virtual void Reset() OVERRIDE;
-  virtual void CompleteRead() OVERRIDE {}
+  virtual MockWriteResult OnWrite(const std::string& data) override;
+  virtual void Reset() override;
+  virtual void CompleteRead() override {}
 
  private:
   // Invoke the read and write callbacks, if the timing is appropriate.
@@ -654,17 +654,17 @@
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
   virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE;
-  virtual void ClearSSLSessionCache() OVERRIDE;
+      const SSLClientSocketContext& context) override;
+  virtual void ClearSSLSessionCache() override;
 
  private:
   SocketDataProviderArray<SocketDataProvider> mock_data_;
@@ -688,34 +688,34 @@
   virtual int Write(IOBuffer* buf,
                     int buf_len,
                     const CompletionCallback& callback) = 0;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // StreamSocket implementation.
   virtual int Connect(const CompletionCallback& callback) = 0;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
 
   // SSLClientSocket implementation.
-  virtual std::string GetSessionCacheKey() const OVERRIDE;
-  virtual bool InSessionCache() const OVERRIDE;
-  virtual void SetHandshakeCompletionCallback(const base::Closure& cb) OVERRIDE;
+  virtual std::string GetSessionCacheKey() const override;
+  virtual bool InSessionCache() const override;
+  virtual void SetHandshakeCompletionCallback(const base::Closure& cb) override;
   virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      OVERRIDE;
+      override;
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    bool has_context,
                                    const base::StringPiece& context,
                                    unsigned char* out,
-                                   unsigned int outlen) OVERRIDE;
-  virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
-  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
-  virtual ChannelIDService* GetChannelIDService() const OVERRIDE;
+                                   unsigned int outlen) override;
+  virtual int GetTLSUniqueChannelBinding(std::string* out) override;
+  virtual NextProtoStatus GetNextProto(std::string* proto) override;
+  virtual ChannelIDService* GetChannelIDService() const override;
 
  protected:
   virtual ~MockClientSocket();
@@ -724,7 +724,7 @@
 
   // SSLClientSocket implementation.
   virtual scoped_refptr<X509Certificate> GetUnverifiedServerCertificateChain()
-      const OVERRIDE;
+      const override;
 
   // True if Connect completed successfully and Disconnect hasn't been called.
   bool connected_;
@@ -752,25 +752,25 @@
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // AsyncSocket:
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
  private:
   int CompleteRead();
@@ -854,33 +854,33 @@
   virtual ~DeterministicMockUDPClientSocket();
 
   // DeterministicSocketData::Delegate:
-  virtual bool WritePending() const OVERRIDE;
-  virtual bool ReadPending() const OVERRIDE;
-  virtual void CompleteWrite() OVERRIDE;
-  virtual int CompleteRead() OVERRIDE;
+  virtual bool WritePending() const override;
+  virtual bool ReadPending() const override;
+  virtual void CompleteWrite() override;
+  virtual int CompleteRead() override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // DatagramSocket implementation.
-  virtual void Close() OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
+  virtual void Close() override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
 
   // DatagramClientSocket implementation.
-  virtual int Connect(const IPEndPoint& address) OVERRIDE;
+  virtual int Connect(const IPEndPoint& address) override;
 
   // AsyncSocket implementation.
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
   void set_source_port(int port) { source_port_ = port; }
 
@@ -905,32 +905,32 @@
   virtual ~DeterministicMockTCPClientSocket();
 
   // DeterministicSocketData::Delegate:
-  virtual bool WritePending() const OVERRIDE;
-  virtual bool ReadPending() const OVERRIDE;
-  virtual void CompleteWrite() OVERRIDE;
-  virtual int CompleteRead() OVERRIDE;
+  virtual bool WritePending() const override;
+  virtual bool ReadPending() const override;
+  virtual void CompleteWrite() override;
+  virtual int CompleteRead() override;
 
   // Socket:
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
 
   // StreamSocket:
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // AsyncSocket:
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
  private:
   DeterministicSocketHelper helper_;
@@ -949,39 +949,39 @@
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // SSLClientSocket implementation.
-  virtual std::string GetSessionCacheKey() const OVERRIDE;
-  virtual bool InSessionCache() const OVERRIDE;
-  virtual void SetHandshakeCompletionCallback(const base::Closure& cb) OVERRIDE;
+  virtual std::string GetSessionCacheKey() const override;
+  virtual bool InSessionCache() const override;
+  virtual void SetHandshakeCompletionCallback(const base::Closure& cb) override;
   virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      OVERRIDE;
-  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
-  virtual bool set_was_npn_negotiated(bool negotiated) OVERRIDE;
-  virtual void set_protocol_negotiated(NextProto protocol_negotiated) OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
+      override;
+  virtual NextProtoStatus GetNextProto(std::string* proto) override;
+  virtual bool set_was_npn_negotiated(bool negotiated) override;
+  virtual void set_protocol_negotiated(NextProto protocol_negotiated) override;
+  virtual NextProto GetNegotiatedProtocol() const override;
 
   // This MockSocket does not implement the manual async IO feature.
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
-  virtual bool WasChannelIDSent() const OVERRIDE;
-  virtual void set_channel_id_sent(bool channel_id_sent) OVERRIDE;
-  virtual ChannelIDService* GetChannelIDService() const OVERRIDE;
+  virtual bool WasChannelIDSent() const override;
+  virtual void set_channel_id_sent(bool channel_id_sent) override;
+  virtual ChannelIDService* GetChannelIDService() const override;
 
   bool reached_connect() const { return reached_connect_; }
 
@@ -1033,25 +1033,25 @@
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // DatagramSocket implementation.
-  virtual void Close() OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
+  virtual void Close() override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
 
   // DatagramClientSocket implementation.
-  virtual int Connect(const IPEndPoint& address) OVERRIDE;
+  virtual int Connect(const IPEndPoint& address) override;
 
   // AsyncSocket implementation.
-  virtual void OnReadComplete(const MockRead& data) OVERRIDE;
-  virtual void OnConnectComplete(const MockConnect& data) OVERRIDE;
+  virtual void OnReadComplete(const MockRead& data) override;
+  virtual void OnConnectComplete(const MockConnect& data) override;
 
   void set_source_port(int port) { source_port_ = port;}
 
@@ -1221,13 +1221,13 @@
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
+                             int id) override;
 
  private:
   ClientSocketFactory* client_socket_factory_;
@@ -1267,17 +1267,17 @@
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
   virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE;
-  virtual void ClearSSLSessionCache() OVERRIDE;
+      const SSLClientSocketContext& context) override;
+  virtual void ClearSSLSessionCache() override;
 
  private:
   SocketDataProviderArray<DeterministicSocketData> mock_data_;
@@ -1306,13 +1306,13 @@
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
+                             int id) override;
 
  private:
   TransportClientSocketPool* const transport_pool_;
diff --git a/net/socket/socks5_client_socket.h b/net/socket/socks5_client_socket.h
index 8da0b4d..5d4e060 100644
--- a/net/socket/socks5_client_socket.h
+++ b/net/socket/socks5_client_socket.h
@@ -43,32 +43,32 @@
   // StreamSocket implementation.
 
   // Does the SOCKS handshake and completes the protocol.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
 
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
 
  private:
   enum State {
diff --git a/net/socket/socks_client_socket.h b/net/socket/socks_client_socket.h
index 26da332..d480de4 100644
--- a/net/socket/socks_client_socket.h
+++ b/net/socket/socks_client_socket.h
@@ -40,32 +40,32 @@
   // StreamSocket implementation.
 
   // Does the SOCKS handshake and completes the protocol.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
 
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SOCKSClientSocketTest, CompleteHandshake);
diff --git a/net/socket/socks_client_socket_pool.h b/net/socket/socks_client_socket_pool.h
index c6d5c8d..d324f0a 100644
--- a/net/socket/socks_client_socket_pool.h
+++ b/net/socket/socks_client_socket_pool.h
@@ -66,7 +66,7 @@
   virtual ~SOCKSConnectJob();
 
   // ConnectJob methods.
-  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual LoadState GetLoadState() const override;
 
  private:
   enum State {
@@ -90,7 +90,7 @@
   // Begins the transport connection and the SOCKS handshake.  Returns OK on
   // success and ERR_IO_PENDING if it cannot immediately service the request.
   // Otherwise, it returns a net error code.
-  virtual int ConnectInternal() OVERRIDE;
+  virtual int ConnectInternal() override;
 
   scoped_refptr<SOCKSSocketParams> socks_params_;
   TransportClientSocketPool* const transport_pool_;
@@ -125,51 +125,51 @@
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
 
   virtual void RequestSockets(const std::string& group_name,
                               const void* params,
                               int num_sockets,
-                              const BoundNetLog& net_log) OVERRIDE;
+                              const BoundNetLog& net_log) override;
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
 
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
+                             int id) override;
 
-  virtual void FlushWithError(int error) OVERRIDE;
+  virtual void FlushWithError(int error) override;
 
-  virtual void CloseIdleSockets() OVERRIDE;
+  virtual void CloseIdleSockets() override;
 
-  virtual int IdleSocketCount() const OVERRIDE;
+  virtual int IdleSocketCount() const override;
 
   virtual int IdleSocketCountInGroup(
-      const std::string& group_name) const OVERRIDE;
+      const std::string& group_name) const override;
 
   virtual LoadState GetLoadState(
       const std::string& group_name,
-      const ClientSocketHandle* handle) const OVERRIDE;
+      const ClientSocketHandle* handle) const override;
 
   virtual base::DictionaryValue* GetInfoAsValue(
       const std::string& name,
       const std::string& type,
-      bool include_nested_pools) const OVERRIDE;
+      bool include_nested_pools) const override;
 
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
+  virtual base::TimeDelta ConnectionTimeout() const override;
 
-  virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
+  virtual ClientSocketPoolHistograms* histograms() const override;
 
   // LowerLayeredPool implementation.
-  virtual bool IsStalled() const OVERRIDE;
+  virtual bool IsStalled() const override;
 
-  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
+  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 
-  virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
+  virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 
   // HigherLayeredPool implementation.
-  virtual bool CloseOneIdleConnection() OVERRIDE;
+  virtual bool CloseOneIdleConnection() override;
 
  private:
   typedef ClientSocketPoolBase<SOCKSSocketParams> PoolBase;
@@ -189,9 +189,9 @@
     virtual scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const PoolBase::Request& request,
-        ConnectJob::Delegate* delegate) const OVERRIDE;
+        ConnectJob::Delegate* delegate) const override;
 
-    virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
+    virtual base::TimeDelta ConnectionTimeout() const override;
 
    private:
     TransportClientSocketPool* const transport_pool_;
diff --git a/net/socket/socks_client_socket_unittest.cc b/net/socket/socks_client_socket_unittest.cc
index c8032e6..e3dc359 100644
--- a/net/socket/socks_client_socket_unittest.cc
+++ b/net/socket/socks_client_socket_unittest.cc
@@ -101,7 +101,7 @@
                       AddressList* addresses,
                       const CompletionCallback& callback,
                       RequestHandle* out_req,
-                      const BoundNetLog& net_log) OVERRIDE {
+                      const BoundNetLog& net_log) override {
     DCHECK(addresses);
     DCHECK_EQ(false, callback.is_null());
     EXPECT_FALSE(HasOutstandingRequest());
@@ -112,12 +112,12 @@
 
   virtual int ResolveFromCache(const RequestInfo& info,
                                AddressList* addresses,
-                               const BoundNetLog& net_log) OVERRIDE {
+                               const BoundNetLog& net_log) override {
     NOTIMPLEMENTED();
     return ERR_UNEXPECTED;
   }
 
-  virtual void CancelRequest(RequestHandle req) OVERRIDE {
+  virtual void CancelRequest(RequestHandle req) override {
     EXPECT_TRUE(HasOutstandingRequest());
     EXPECT_EQ(outstanding_request_, req);
     outstanding_request_ = NULL;
diff --git a/net/socket/ssl_client_socket.cc b/net/socket/ssl_client_socket.cc
index 4aacbc8..da2d6ba 100644
--- a/net/socket/ssl_client_socket.cc
+++ b/net/socket/ssl_client_socket.cc
@@ -5,6 +5,7 @@
 #include "net/socket/ssl_client_socket.h"
 
 #include "base/metrics/histogram.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
 #include "crypto/ec_private_key.h"
 #include "net/base/host_port_pair.h"
@@ -19,7 +20,8 @@
       protocol_negotiated_(kProtoUnknown),
       channel_id_sent_(false),
       signed_cert_timestamps_received_(false),
-      stapled_ocsp_response_received_(false) {
+      stapled_ocsp_response_received_(false),
+      negotiation_extension_(kExtensionUnknown) {
 }
 
 // static
@@ -124,6 +126,11 @@
   protocol_negotiated_ = protocol_negotiated;
 }
 
+void SSLClientSocket::set_negotiation_extension(
+    SSLNegotiationExtension negotiation_extension) {
+  negotiation_extension_ = negotiation_extension;
+}
+
 bool SSLClientSocket::WasChannelIDSent() const {
   return channel_id_sent_;
 }
@@ -232,4 +239,30 @@
   return wire_protos;
 }
 
+void SSLClientSocket::RecordNegotiationExtension() {
+  if (negotiation_extension_ == kExtensionUnknown)
+    return;
+  std::string proto;
+  SSLClientSocket::NextProtoStatus status = GetNextProto(&proto);
+  if (status == kNextProtoUnsupported)
+    return;
+  // Convert protocol into numerical value for histogram.
+  NextProto protocol_negotiated = SSLClientSocket::NextProtoFromString(proto);
+  base::HistogramBase::Sample sample =
+      static_cast<base::HistogramBase::Sample>(protocol_negotiated);
+  // In addition to the protocol negotiated, we want to record which TLS
+  // extension was used, and in case of NPN, whether there was overlap between
+  // server and client list of supported protocols.
+  if (negotiation_extension_ == kExtensionNPN) {
+    if (status == kNextProtoNoOverlap) {
+      sample += 1000;
+    } else {
+      sample += 500;
+    }
+  } else {
+    DCHECK_EQ(kExtensionALPN, negotiation_extension_);
+  }
+  UMA_HISTOGRAM_SPARSE_SLOWLY("Net.SSLProtocolNegotiation", sample);
+}
+
 }  // namespace net
diff --git a/net/socket/ssl_client_socket.h b/net/socket/ssl_client_socket.h
index 0e32ed6..8f40f84 100644
--- a/net/socket/ssl_client_socket.h
+++ b/net/socket/ssl_client_socket.h
@@ -79,9 +79,16 @@
                                 // the first protocol in our list.
   };
 
+  // TLS extension used to negotiate protocol.
+  enum SSLNegotiationExtension {
+    kExtensionUnknown,
+    kExtensionALPN,
+    kExtensionNPN,
+  };
+
   // StreamSocket:
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
 
   // Computes a unique key string for the SSL session cache.
   virtual std::string GetSessionCacheKey() const = 0;
@@ -150,6 +157,8 @@
 
   virtual void set_protocol_negotiated(NextProto protocol_negotiated);
 
+  void set_negotiation_extension(SSLNegotiationExtension negotiation_extension);
+
   // Returns the ChannelIDService used by this socket, or NULL if
   // channel ids are not supported.
   virtual ChannelIDService* GetChannelIDService() const = 0;
@@ -162,6 +171,10 @@
   // Public for ssl_client_socket_openssl_unittest.cc.
   virtual bool WasChannelIDSent() const;
 
+  // Record which TLS extension was used to negotiate protocol and protocol
+  // chosen in a UMA histogram.
+  void RecordNegotiationExtension();
+
  protected:
   virtual void set_channel_id_sent(bool channel_id_sent);
 
@@ -219,6 +232,8 @@
   bool signed_cert_timestamps_received_;
   // True if a stapled OCSP response was received.
   bool stapled_ocsp_response_received_;
+  // Protocol negotiation extension used.
+  SSLNegotiationExtension negotiation_extension_;
 };
 
 }  // namespace net
diff --git a/net/socket/ssl_client_socket_nss.cc b/net/socket/ssl_client_socket_nss.cc
index c5869fc..92660d8 100644
--- a/net/socket/ssl_client_socket_nss.cc
+++ b/net/socket/ssl_client_socket_nss.cc
@@ -71,6 +71,7 @@
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ -407,6 +408,7 @@
   void Reset() {
     next_proto_status = SSLClientSocket::kNextProtoUnsupported;
     next_proto.clear();
+    negotiation_extension_ = SSLClientSocket::kExtensionUnknown;
     channel_id_sent = false;
     server_cert_chain.Reset(NULL);
     server_cert = NULL;
@@ -421,6 +423,9 @@
   SSLClientSocket::NextProtoStatus next_proto_status;
   std::string next_proto;
 
+  // TLS extension used for protocol negotiation.
+  SSLClientSocket::SSLNegotiationExtension negotiation_extension_;
+
   // True if a channel ID was sent.
   bool channel_id_sent;
 
@@ -759,6 +764,8 @@
   // UpdateNextProto gets any application-layer protocol that may have been
   // negotiated by the TLS connection.
   void UpdateNextProto();
+  // Record TLS extension used for protocol negotiation (NPN or ALPN).
+  void UpdateExtensionUsed();
 
   ////////////////////////////////////////////////////////////////////////////
   // Methods that are ONLY called on the network task runner:
@@ -1640,6 +1647,7 @@
   UpdateStapledOCSPResponse();
   UpdateConnectionStatus();
   UpdateNextProto();
+  UpdateExtensionUsed();
 
   // Update the network task runners view of the handshake state whenever
   // a handshake has completed.
@@ -2213,6 +2221,10 @@
   PostOrRunCallback(
       FROM_HERE,
       base::Bind(&Core::DidNSSRead, this, rv));
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "SSLClientSocketNSS::Core::DoReadCallback"));
   PostOrRunCallback(
       FROM_HERE,
       base::Bind(base::ResetAndReturn(&user_read_callback_), rv));
@@ -2491,6 +2503,23 @@
   }
 }
 
+void SSLClientSocketNSS::Core::UpdateExtensionUsed() {
+  PRBool negotiated_extension;
+  SECStatus rv = SSL_HandshakeNegotiatedExtension(nss_fd_,
+                                                  ssl_app_layer_protocol_xtn,
+                                                  &negotiated_extension);
+  if (rv == SECSuccess && negotiated_extension) {
+    nss_handshake_state_.negotiation_extension_ = kExtensionALPN;
+  } else {
+    rv = SSL_HandshakeNegotiatedExtension(nss_fd_,
+                                          ssl_next_proto_nego_xtn,
+                                          &negotiated_extension);
+    if (rv == SECSuccess && negotiated_extension) {
+      nss_handshake_state_.negotiation_extension_ = kExtensionNPN;
+    }
+  }
+}
+
 void SSLClientSocketNSS::Core::RecordChannelIDSupportOnNSSTaskRunner() {
   DCHECK(OnNSSTaskRunner());
   if (nss_handshake_state_.resumed_handshake)
@@ -2623,6 +2652,11 @@
 }
 
 void SSLClientSocketNSS::Core::BufferSendComplete(int result) {
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "418183 DidCompleteReadWrite => Core::BufferSendComplete"));
+
   if (!OnNSSTaskRunner()) {
     if (detached_)
       return;
@@ -2666,6 +2700,11 @@
 void SSLClientSocketNSS::Core::BufferRecvComplete(
     IOBuffer* read_buffer,
     int result) {
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "418183 DidCompleteReadWrite => SSLClientSocketNSS::Core::..."));
+
   DCHECK(read_buffer);
 
   if (!OnNSSTaskRunner()) {
@@ -3314,6 +3353,11 @@
   EnterFunction(result);
 
   if (result == OK) {
+    if (ssl_config_.version_fallback &&
+        ssl_config_.version_max < ssl_config_.version_fallback_min) {
+      return ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION;
+    }
+
     // SSL handshake is completed. Let's verify the certificate.
     GotoState(STATE_VERIFY_CERT);
     // Done!
@@ -3323,6 +3367,7 @@
       !core_->state().sct_list_from_tls_extension.empty());
   set_stapled_ocsp_response_received(
       !core_->state().stapled_ocsp_response.empty());
+  set_negotiation_extension(core_->state().negotiation_extension_);
 
   LeaveFunction(result);
   return result;
diff --git a/net/socket/ssl_client_socket_nss.h b/net/socket/ssl_client_socket_nss.h
index a2dc610..ccdbb81 100644
--- a/net/socket/ssl_client_socket_nss.h
+++ b/net/socket/ssl_client_socket_nss.h
@@ -68,51 +68,51 @@
   virtual ~SSLClientSocketNSS();
 
   // SSLClientSocket implementation.
-  virtual std::string GetSessionCacheKey() const OVERRIDE;
-  virtual bool InSessionCache() const OVERRIDE;
+  virtual std::string GetSessionCacheKey() const override;
+  virtual bool InSessionCache() const override;
   virtual void SetHandshakeCompletionCallback(
-      const base::Closure& callback) OVERRIDE;
+      const base::Closure& callback) override;
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
-  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
+  virtual NextProtoStatus GetNextProto(std::string* proto) override;
 
   // SSLSocket implementation.
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    bool has_context,
                                    const base::StringPiece& context,
                                    unsigned char* out,
-                                   unsigned int outlen) OVERRIDE;
-  virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
+                                   unsigned int outlen) override;
+  virtual int GetTLSUniqueChannelBinding(std::string* out) override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
-  virtual ChannelIDService* GetChannelIDService() const OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
+  virtual ChannelIDService* GetChannelIDService() const override;
 
  protected:
   // SSLClientSocket implementation.
   virtual scoped_refptr<X509Certificate> GetUnverifiedServerCertificateChain()
-      const OVERRIDE;
+      const override;
 
  private:
   // Helper class to handle marshalling any NSS interaction to and from the
diff --git a/net/socket/ssl_client_socket_openssl.cc b/net/socket/ssl_client_socket_openssl.cc
index f341a9f..04be988 100644
--- a/net/socket/ssl_client_socket_openssl.cc
+++ b/net/socket/ssl_client_socket_openssl.cc
@@ -907,6 +907,11 @@
                << " is: " << (SSL_session_reused(ssl_) ? "Success" : "Fail");
     }
 
+    if (ssl_config_.version_fallback &&
+        ssl_config_.version_max < ssl_config_.version_fallback_min) {
+      return ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION;
+    }
+
     // SSL handshake is completed. If NPN wasn't negotiated, see if ALPN was.
     if (npn_status_ == kNextProtoUnsupported) {
       const uint8_t* alpn_proto = NULL;
@@ -915,6 +920,7 @@
       if (alpn_len > 0) {
         npn_proto_.assign(reinterpret_cast<const char*>(alpn_proto), alpn_len);
         npn_status_ = kNextProtoNegotiated;
+        set_negotiation_extension(kExtensionALPN);
       }
     }
 
@@ -1669,6 +1675,7 @@
 
   npn_proto_.assign(reinterpret_cast<const char*>(*out), *outlen);
   DVLOG(2) << "next protocol: '" << npn_proto_ << "' status: " << npn_status_;
+  set_negotiation_extension(kExtensionNPN);
   return SSL_TLSEXT_ERR_OK;
 }
 
diff --git a/net/socket/ssl_client_socket_openssl.h b/net/socket/ssl_client_socket_openssl.h
index 1465f84..dff457b 100644
--- a/net/socket/ssl_client_socket_openssl.h
+++ b/net/socket/ssl_client_socket_openssl.h
@@ -59,49 +59,49 @@
   }
 
   // SSLClientSocket implementation.
-  virtual std::string GetSessionCacheKey() const OVERRIDE;
-  virtual bool InSessionCache() const OVERRIDE;
+  virtual std::string GetSessionCacheKey() const override;
+  virtual bool InSessionCache() const override;
   virtual void SetHandshakeCompletionCallback(
-      const base::Closure& callback) OVERRIDE;
+      const base::Closure& callback) override;
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
-  virtual NextProtoStatus GetNextProto(std::string* proto) OVERRIDE;
-  virtual ChannelIDService* GetChannelIDService() const OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
+  virtual NextProtoStatus GetNextProto(std::string* proto) override;
+  virtual ChannelIDService* GetChannelIDService() const override;
 
   // SSLSocket implementation.
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    bool has_context,
                                    const base::StringPiece& context,
                                    unsigned char* out,
-                                   unsigned int outlen) OVERRIDE;
-  virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
+                                   unsigned int outlen) override;
+  virtual int GetTLSUniqueChannelBinding(std::string* out) override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
  protected:
   // SSLClientSocket implementation.
   virtual scoped_refptr<X509Certificate> GetUnverifiedServerCertificateChain()
-      const OVERRIDE;
+      const override;
 
  private:
   class PeerCertificateChain;
diff --git a/net/socket/ssl_client_socket_pool.cc b/net/socket/ssl_client_socket_pool.cc
index 6356783..a866b6c 100644
--- a/net/socket/ssl_client_socket_pool.cc
+++ b/net/socket/ssl_client_socket_pool.cc
@@ -452,8 +452,10 @@
   // GetNextProto will fail and and trigger a NOTREACHED if we pass in a socket
   // that hasn't had SSL_ImportFD called on it. If we get a certificate error
   // here, then we know that we called SSL_ImportFD.
-  if (result == OK || IsCertificateError(result))
+  if (result == OK || IsCertificateError(result)) {
     status = ssl_socket_->GetNextProto(&proto);
+    ssl_socket_->RecordNegotiationExtension();
+  }
 
   // If we want spdy over npn, make sure it succeeded.
   if (status == SSLClientSocket::kNextProtoNegotiated) {
diff --git a/net/socket/ssl_client_socket_pool.h b/net/socket/ssl_client_socket_pool.h
index efcce77..5854015 100644
--- a/net/socket/ssl_client_socket_pool.h
+++ b/net/socket/ssl_client_socket_pool.h
@@ -197,9 +197,9 @@
   virtual ~SSLConnectJob();
 
   // ConnectJob methods.
-  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual LoadState GetLoadState() const override;
 
-  virtual void GetAdditionalErrorState(ClientSocketHandle * handle) OVERRIDE;
+  virtual void GetAdditionalErrorState(ClientSocketHandle * handle) override;
 
  private:
   enum State {
@@ -242,7 +242,7 @@
   // Starts the SSL connection process.  Returns OK on success and
   // ERR_IO_PENDING if it cannot immediately service the request.
   // Otherwise, it returns a net error code.
-  virtual int ConnectInternal() OVERRIDE;
+  virtual int ConnectInternal() override;
 
   scoped_refptr<SSLSocketParams> params_;
   TransportClientSocketPool* const transport_pool_;
@@ -302,51 +302,51 @@
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
 
   virtual void RequestSockets(const std::string& group_name,
                               const void* params,
                               int num_sockets,
-                              const BoundNetLog& net_log) OVERRIDE;
+                              const BoundNetLog& net_log) override;
 
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
 
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
+                             int id) override;
 
-  virtual void FlushWithError(int error) OVERRIDE;
+  virtual void FlushWithError(int error) override;
 
-  virtual void CloseIdleSockets() OVERRIDE;
+  virtual void CloseIdleSockets() override;
 
-  virtual int IdleSocketCount() const OVERRIDE;
+  virtual int IdleSocketCount() const override;
 
   virtual int IdleSocketCountInGroup(
-      const std::string& group_name) const OVERRIDE;
+      const std::string& group_name) const override;
 
   virtual LoadState GetLoadState(
       const std::string& group_name,
-      const ClientSocketHandle* handle) const OVERRIDE;
+      const ClientSocketHandle* handle) const override;
 
   virtual base::DictionaryValue* GetInfoAsValue(
       const std::string& name,
       const std::string& type,
-      bool include_nested_pools) const OVERRIDE;
+      bool include_nested_pools) const override;
 
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
+  virtual base::TimeDelta ConnectionTimeout() const override;
 
-  virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
+  virtual ClientSocketPoolHistograms* histograms() const override;
 
   // LowerLayeredPool implementation.
-  virtual bool IsStalled() const OVERRIDE;
+  virtual bool IsStalled() const override;
 
-  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
+  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 
-  virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
+  virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 
   // HigherLayeredPool implementation.
-  virtual bool CloseOneIdleConnection() OVERRIDE;
+  virtual bool CloseOneIdleConnection() override;
 
   // Gets the SSLConnectJobMessenger for the given ssl session |cache_key|. If
   // none exits, it creates one and stores it in |messenger_map_|.
@@ -363,7 +363,7 @@
 
   // When the user changes the SSL config, we flush all idle sockets so they
   // won't get re-used.
-  virtual void OnSSLConfigChanged() OVERRIDE;
+  virtual void OnSSLConfigChanged() override;
 
   class SSLConnectJobFactory : public PoolBase::ConnectJobFactory {
    public:
@@ -383,9 +383,9 @@
     virtual scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const PoolBase::Request& request,
-        ConnectJob::Delegate* delegate) const OVERRIDE;
+        ConnectJob::Delegate* delegate) const override;
 
-    virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
+    virtual base::TimeDelta ConnectionTimeout() const override;
 
    private:
     TransportClientSocketPool* const transport_pool_;
diff --git a/net/socket/ssl_client_socket_unittest.cc b/net/socket/ssl_client_socket_unittest.cc
index 4e844cd..40a4d3c 100644
--- a/net/socket/ssl_client_socket_unittest.cc
+++ b/net/socket/ssl_client_socket_unittest.cc
@@ -60,62 +60,62 @@
   virtual ~WrappedStreamSocket() {}
 
   // StreamSocket implementation:
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     return transport_->Connect(callback);
   }
-  virtual void Disconnect() OVERRIDE { transport_->Disconnect(); }
-  virtual bool IsConnected() const OVERRIDE {
+  virtual void Disconnect() override { transport_->Disconnect(); }
+  virtual bool IsConnected() const override {
     return transport_->IsConnected();
   }
-  virtual bool IsConnectedAndIdle() const OVERRIDE {
+  virtual bool IsConnectedAndIdle() const override {
     return transport_->IsConnectedAndIdle();
   }
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     return transport_->GetPeerAddress(address);
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     return transport_->GetLocalAddress(address);
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE {
+  virtual const BoundNetLog& NetLog() const override {
     return transport_->NetLog();
   }
-  virtual void SetSubresourceSpeculation() OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {
     transport_->SetSubresourceSpeculation();
   }
-  virtual void SetOmniboxSpeculation() OVERRIDE {
+  virtual void SetOmniboxSpeculation() override {
     transport_->SetOmniboxSpeculation();
   }
-  virtual bool WasEverUsed() const OVERRIDE {
+  virtual bool WasEverUsed() const override {
     return transport_->WasEverUsed();
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override {
     return transport_->UsingTCPFastOpen();
   }
-  virtual bool WasNpnNegotiated() const OVERRIDE {
+  virtual bool WasNpnNegotiated() const override {
     return transport_->WasNpnNegotiated();
   }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual NextProto GetNegotiatedProtocol() const override {
     return transport_->GetNegotiatedProtocol();
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override {
     return transport_->GetSSLInfo(ssl_info);
   }
 
   // Socket implementation:
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return transport_->Read(buf, buf_len, callback);
   }
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return transport_->Write(buf, buf_len, callback);
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
+  virtual int SetReceiveBufferSize(int32 size) override {
     return transport_->SetReceiveBufferSize(size);
   }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE {
+  virtual int SetSendBufferSize(int32 size) override {
     return transport_->SetSendBufferSize(size);
   }
 
@@ -137,7 +137,7 @@
   // Socket implementation:
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
 
   // Sets the internal buffer to |size|. This must not be greater than
   // the largest value supplied to Read() - that is, it does not handle
@@ -267,10 +267,10 @@
   // Socket implementation:
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
 
   // Sets the next Read() call and all future calls to return |error|.
   // If there is already a pending asynchronous read, the configured error
@@ -338,10 +338,10 @@
   // Socket implementation:
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
+                    const CompletionCallback& callback) override;
 
   // Blocks read results on the socket. Reads will not complete until
   // UnblockReadResult() has been called and a result is ready from the
@@ -554,13 +554,13 @@
   // Socket implementation:
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     read_count_++;
     return transport_->Read(buf, buf_len, callback);
   }
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     write_count_++;
     return transport_->Write(buf, buf_len, callback);
   }
@@ -609,26 +609,26 @@
                            base::Time* expiration_time,
                            std::string* private_key_result,
                            std::string* cert_result,
-                           const GetChannelIDCallback& callback) OVERRIDE {
+                           const GetChannelIDCallback& callback) override {
     return ERR_UNEXPECTED;
   }
   virtual void SetChannelID(const std::string& server_identifier,
                             base::Time creation_time,
                             base::Time expiration_time,
                             const std::string& private_key,
-                            const std::string& cert) OVERRIDE {}
+                            const std::string& cert) override {}
   virtual void DeleteChannelID(const std::string& server_identifier,
                                const base::Closure& completion_callback)
-      OVERRIDE {}
+      override {}
   virtual void DeleteAllCreatedBetween(base::Time delete_begin,
                                        base::Time delete_end,
                                        const base::Closure& completion_callback)
-      OVERRIDE {}
-  virtual void DeleteAll(const base::Closure& completion_callback) OVERRIDE {}
+      override {}
+  virtual void DeleteAll(const base::Closure& completion_callback) override {}
   virtual void GetAllChannelIDs(const GetChannelIDListCallback& callback)
-      OVERRIDE {}
-  virtual int GetChannelIDCount() OVERRIDE { return 0; }
-  virtual void SetForceKeepSessionState() OVERRIDE {}
+      override {}
+  virtual int GetChannelIDCount() override { return 0; }
+  virtual void SetForceKeepSessionState() override {}
 };
 
 // A ChannelIDStore that asynchronously returns an error when asked for a
@@ -638,7 +638,7 @@
                            base::Time* expiration_time,
                            std::string* private_key_result,
                            std::string* cert_result,
-                           const GetChannelIDCallback& callback) OVERRIDE {
+                           const GetChannelIDCallback& callback) override {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERR_UNEXPECTED,
                               server_identifier, base::Time(), "", ""));
@@ -648,19 +648,19 @@
                             base::Time creation_time,
                             base::Time expiration_time,
                             const std::string& private_key,
-                            const std::string& cert) OVERRIDE {}
+                            const std::string& cert) override {}
   virtual void DeleteChannelID(const std::string& server_identifier,
                                const base::Closure& completion_callback)
-      OVERRIDE {}
+      override {}
   virtual void DeleteAllCreatedBetween(base::Time delete_begin,
                                        base::Time delete_end,
                                        const base::Closure& completion_callback)
-      OVERRIDE {}
-  virtual void DeleteAll(const base::Closure& completion_callback) OVERRIDE {}
+      override {}
+  virtual void DeleteAll(const base::Closure& completion_callback) override {}
   virtual void GetAllChannelIDs(const GetChannelIDListCallback& callback)
-      OVERRIDE {}
-  virtual int GetChannelIDCount() OVERRIDE { return 0; }
-  virtual void SetForceKeepSessionState() OVERRIDE {}
+      override {}
+  virtual int GetChannelIDCount() override { return 0; }
+  virtual void SetForceKeepSessionState() override {}
 };
 
 // A mock CTVerifier that records every call to Verify but doesn't verify
diff --git a/net/socket/ssl_server_socket_nss.h b/net/socket/ssl_server_socket_nss.h
index bc5b65d..eddb543 100644
--- a/net/socket/ssl_server_socket_nss.h
+++ b/net/socket/ssl_server_socket_nss.h
@@ -31,39 +31,39 @@
   virtual ~SSLServerSocketNSS();
 
   // SSLServerSocket interface.
-  virtual int Handshake(const CompletionCallback& callback) OVERRIDE;
+  virtual int Handshake(const CompletionCallback& callback) override;
 
   // SSLSocket interface.
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    bool has_context,
                                    const base::StringPiece& context,
                                    unsigned char* out,
-                                   unsigned int outlen) OVERRIDE;
-  virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
+                                   unsigned int outlen) override;
+  virtual int GetTLSUniqueChannelBinding(std::string* out) override;
 
   // Socket interface (via StreamSocket).
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
  private:
   enum State {
diff --git a/net/socket/ssl_server_socket_openssl.h b/net/socket/ssl_server_socket_openssl.h
index e1c8aad..379ca57 100644
--- a/net/socket/ssl_server_socket_openssl.h
+++ b/net/socket/ssl_server_socket_openssl.h
@@ -33,39 +33,39 @@
   virtual ~SSLServerSocketOpenSSL();
 
   // SSLServerSocket interface.
-  virtual int Handshake(const CompletionCallback& callback) OVERRIDE;
+  virtual int Handshake(const CompletionCallback& callback) override;
 
   // SSLSocket interface.
   virtual int ExportKeyingMaterial(const base::StringPiece& label,
                                    bool has_context,
                                    const base::StringPiece& context,
                                    unsigned char* out,
-                                   unsigned int outlen) OVERRIDE;
-  virtual int GetTLSUniqueChannelBinding(std::string* out) OVERRIDE;
+                                   unsigned int outlen) override;
+  virtual int GetTLSUniqueChannelBinding(std::string* out) override;
 
   // Socket interface (via StreamSocket).
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
  private:
   enum State {
diff --git a/net/socket/ssl_server_socket_unittest.cc b/net/socket/ssl_server_socket_unittest.cc
index f28d51a..1d70258 100644
--- a/net/socket/ssl_server_socket_unittest.cc
+++ b/net/socket/ssl_server_socket_unittest.cc
@@ -171,81 +171,81 @@
   }
 
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     // Read random number of bytes.
     buf_len = rand() % buf_len + 1;
     return incoming_->Read(buf, buf_len, callback);
   }
 
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     // Write random number of bytes.
     buf_len = rand() % buf_len + 1;
     return outgoing_->Write(buf, buf_len, callback);
   }
 
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE {
+  virtual int SetReceiveBufferSize(int32 size) override {
     return OK;
   }
 
-  virtual int SetSendBufferSize(int32 size) OVERRIDE {
+  virtual int SetSendBufferSize(int32 size) override {
     return OK;
   }
 
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     return OK;
   }
 
-  virtual void Disconnect() OVERRIDE {
+  virtual void Disconnect() override {
     incoming_->Close();
     outgoing_->Close();
   }
 
-  virtual bool IsConnected() const OVERRIDE {
+  virtual bool IsConnected() const override {
     return true;
   }
 
-  virtual bool IsConnectedAndIdle() const OVERRIDE {
+  virtual bool IsConnectedAndIdle() const override {
     return true;
   }
 
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     IPAddressNumber ip_address(kIPv4AddressSize);
     *address = IPEndPoint(ip_address, 0 /*port*/);
     return OK;
   }
 
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     IPAddressNumber ip_address(4);
     *address = IPEndPoint(ip_address, 0);
     return OK;
   }
 
-  virtual const BoundNetLog& NetLog() const OVERRIDE {
+  virtual const BoundNetLog& NetLog() const override {
     return net_log_;
   }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
 
-  virtual bool WasEverUsed() const OVERRIDE {
+  virtual bool WasEverUsed() const override {
     return true;
   }
 
-  virtual bool UsingTCPFastOpen() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override {
     return false;
   }
 
 
-  virtual bool WasNpnNegotiated() const OVERRIDE {
+  virtual bool WasNpnNegotiated() const override {
     return false;
   }
 
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
 
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override {
     return false;
   }
 
diff --git a/net/socket/stream_listen_socket.h b/net/socket/stream_listen_socket.h
index 813d96a..ead35c4 100644
--- a/net/socket/stream_listen_socket.h
+++ b/net/socket/stream_listen_socket.h
@@ -116,8 +116,8 @@
   HANDLE socket_event_;
 #elif defined(OS_POSIX)
   // Called by MessagePumpLibevent when the socket is ready to do I/O.
-  virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE;
-  virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE;
+  virtual void OnFileCanReadWithoutBlocking(int fd) override;
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override;
   WaitState wait_state_;
   // The socket's libevent wrapper.
   base::MessageLoopForIO::FileDescriptorWatcher watcher_;
diff --git a/net/socket/tcp_client_socket.cc b/net/socket/tcp_client_socket.cc
index a16e11e..96402fe 100644
--- a/net/socket/tcp_client_socket.cc
+++ b/net/socket/tcp_client_socket.cc
@@ -6,6 +6,7 @@
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
+#include "base/profiler/scoped_profile.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
@@ -306,6 +307,10 @@
   if (result > 0)
     use_history_.set_was_used_to_convey_data();
 
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "TCPClientSocket::DidCompleteReadWrite"));
   callback.Run(result);
 }
 
diff --git a/net/socket/tcp_client_socket.h b/net/socket/tcp_client_socket.h
index 9322624..1672a95 100644
--- a/net/socket/tcp_client_socket.h
+++ b/net/socket/tcp_client_socket.h
@@ -38,31 +38,31 @@
   int Bind(const IPEndPoint& address);
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual void EnableTCPFastOpenIfSupported() OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual void EnableTCPFastOpenIfSupported() override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // Socket implementation.
   // Multiple outstanding requests are not supported.
   // Full duplex mode (reading and writing at the same time) is supported.
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   virtual bool SetKeepAlive(bool enable, int delay);
   virtual bool SetNoDelay(bool no_delay);
diff --git a/net/socket/tcp_listen_socket.h b/net/socket/tcp_listen_socket.h
index 54a91de..d726dcc 100644
--- a/net/socket/tcp_listen_socket.h
+++ b/net/socket/tcp_listen_socket.h
@@ -34,7 +34,7 @@
   TCPListenSocket(SocketDescriptor s, StreamListenSocket::Delegate* del);
 
   // Implements StreamListenSocket::Accept.
-  virtual void Accept() OVERRIDE;
+  virtual void Accept() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TCPListenSocket);
@@ -48,7 +48,7 @@
 
   // StreamListenSocketFactory overrides.
   virtual scoped_ptr<StreamListenSocket> CreateAndListen(
-      StreamListenSocket::Delegate* delegate) const OVERRIDE;
+      StreamListenSocket::Delegate* delegate) const override;
 
  private:
   const std::string ip_;
diff --git a/net/socket/tcp_listen_socket_unittest.h b/net/socket/tcp_listen_socket_unittest.h
index 1bc31a8..9393370 100644
--- a/net/socket/tcp_listen_socket_unittest.h
+++ b/net/socket/tcp_listen_socket_unittest.h
@@ -91,10 +91,10 @@
 
   // StreamListenSocket::Delegate:
   virtual void DidAccept(StreamListenSocket* server,
-                         scoped_ptr<StreamListenSocket> connection) OVERRIDE;
+                         scoped_ptr<StreamListenSocket> connection) override;
   virtual void DidRead(StreamListenSocket* connection, const char* data,
-                       int len) OVERRIDE;
-  virtual void DidClose(StreamListenSocket* sock) OVERRIDE;
+                       int len) override;
+  virtual void DidClose(StreamListenSocket* sock) override;
 
   scoped_ptr<base::Thread> thread_;
   base::MessageLoopForIO* loop_;
diff --git a/net/socket/tcp_server_socket.h b/net/socket/tcp_server_socket.h
index faff9ad..9fc719a 100644
--- a/net/socket/tcp_server_socket.h
+++ b/net/socket/tcp_server_socket.h
@@ -22,10 +22,10 @@
   virtual ~TCPServerSocket();
 
   // net::ServerSocket implementation.
-  virtual int Listen(const IPEndPoint& address, int backlog) OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+  virtual int Listen(const IPEndPoint& address, int backlog) override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
   virtual int Accept(scoped_ptr<StreamSocket>* socket,
-                     const CompletionCallback& callback) OVERRIDE;
+                     const CompletionCallback& callback) override;
 
  private:
   // Converts |accepted_socket_| and stores the result in
diff --git a/net/socket/tcp_socket_win.cc b/net/socket/tcp_socket_win.cc
index 62966ec..1598948 100644
--- a/net/socket/tcp_socket_win.cc
+++ b/net/socket/tcp_socket_win.cc
@@ -1035,6 +1035,9 @@
   core_->read_buffer_length_ = 0;
 
   DCHECK_NE(rv, ERR_IO_PENDING);
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION("TCPSocketWin::DidSignalRead"));
   base::ResetAndReturn(&read_callback_).Run(rv);
 }
 
diff --git a/net/socket/tcp_socket_win.h b/net/socket/tcp_socket_win.h
index a5eed41..80174ad 100644
--- a/net/socket/tcp_socket_win.h
+++ b/net/socket/tcp_socket_win.h
@@ -101,7 +101,7 @@
   class Core;
 
   // base::ObjectWatcher::Delegate implementation.
-  virtual void OnObjectSignaled(HANDLE object) OVERRIDE;
+  virtual void OnObjectSignaled(HANDLE object) override;
 
   int AcceptInternal(scoped_ptr<TCPSocketWin>* socket,
                      IPEndPoint* address);
diff --git a/net/socket/transport_client_socket_pool.h b/net/socket/transport_client_socket_pool.h
index fce5432..14af726 100644
--- a/net/socket/transport_client_socket_pool.h
+++ b/net/socket/transport_client_socket_pool.h
@@ -167,7 +167,7 @@
   virtual ~TransportConnectJob();
 
   // ConnectJob methods.
-  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual LoadState GetLoadState() const override;
 
   // Rolls |addrlist| forward until the first IPv4 address, if any.
   // WARNING: this method should only be used to implement the prefer-IPv4 hack.
@@ -194,7 +194,7 @@
   // Begins the host resolution and the TCP connect.  Returns OK on success
   // and ERR_IO_PENDING if it cannot immediately service the request.
   // Otherwise, it returns a net error code.
-  virtual int ConnectInternal() OVERRIDE;
+  virtual int ConnectInternal() override;
 
   TransportConnectJobHelper helper_;
 
@@ -231,35 +231,35 @@
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
   virtual void RequestSockets(const std::string& group_name,
                               const void* params,
                               int num_sockets,
-                              const BoundNetLog& net_log) OVERRIDE;
+                              const BoundNetLog& net_log) override;
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
-  virtual void FlushWithError(int error) OVERRIDE;
-  virtual void CloseIdleSockets() OVERRIDE;
-  virtual int IdleSocketCount() const OVERRIDE;
+                             int id) override;
+  virtual void FlushWithError(int error) override;
+  virtual void CloseIdleSockets() override;
+  virtual int IdleSocketCount() const override;
   virtual int IdleSocketCountInGroup(
-      const std::string& group_name) const OVERRIDE;
+      const std::string& group_name) const override;
   virtual LoadState GetLoadState(
       const std::string& group_name,
-      const ClientSocketHandle* handle) const OVERRIDE;
+      const ClientSocketHandle* handle) const override;
   virtual base::DictionaryValue* GetInfoAsValue(
       const std::string& name,
       const std::string& type,
-      bool include_nested_pools) const OVERRIDE;
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
-  virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
+      bool include_nested_pools) const override;
+  virtual base::TimeDelta ConnectionTimeout() const override;
+  virtual ClientSocketPoolHistograms* histograms() const override;
 
   // HigherLayeredPool implementation.
-  virtual bool IsStalled() const OVERRIDE;
-  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
-  virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
+  virtual bool IsStalled() const override;
+  virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) override;
+  virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) override;
 
  protected:
   // Methods shared with WebSocketTransportClientSocketPool
@@ -287,9 +287,9 @@
     virtual scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const PoolBase::Request& request,
-        ConnectJob::Delegate* delegate) const OVERRIDE;
+        ConnectJob::Delegate* delegate) const override;
 
-    virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
+    virtual base::TimeDelta ConnectionTimeout() const override;
 
    private:
     ClientSocketFactory* const client_socket_factory_;
diff --git a/net/socket/transport_client_socket_pool_test_util.cc b/net/socket/transport_client_socket_pool_test_util.cc
index 98a615d..a56c6b1 100644
--- a/net/socket/transport_client_socket_pool_test_util.cc
+++ b/net/socket/transport_client_socket_pool_test_util.cc
@@ -38,19 +38,19 @@
         use_tcp_fastopen_(false) {}
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     connected_ = true;
     return OK;
   }
-  virtual void Disconnect() OVERRIDE { connected_ = false; }
-  virtual bool IsConnected() const OVERRIDE { return connected_; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return connected_; }
+  virtual void Disconnect() override { connected_ = false; }
+  virtual bool IsConnected() const override { return connected_; }
+  virtual bool IsConnectedAndIdle() const override { return connected_; }
 
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     *address = addrlist_.front();
     return OK;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     if (!connected_)
       return ERR_SOCKET_NOT_CONNECTED;
     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
@@ -59,34 +59,34 @@
       SetIPv6Address(address);
     return OK;
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
+  virtual const BoundNetLog& NetLog() const override { return net_log_; }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE { return false; }
-  virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override { return false; }
+  virtual void EnableTCPFastOpenIfSupported() override {
     use_tcp_fastopen_ = true;
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
+  virtual bool WasNpnNegotiated() const override { return false; }
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
+  virtual int SetReceiveBufferSize(int32 size) override { return OK; }
+  virtual int SetSendBufferSize(int32 size) override { return OK; }
 
  private:
   bool connected_;
@@ -105,49 +105,49 @@
         use_tcp_fastopen_(false) {}
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     return ERR_CONNECTION_FAILED;
   }
 
-  virtual void Disconnect() OVERRIDE {}
+  virtual void Disconnect() override {}
 
-  virtual bool IsConnected() const OVERRIDE { return false; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return false; }
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual bool IsConnected() const override { return false; }
+  virtual bool IsConnectedAndIdle() const override { return false; }
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     return ERR_UNEXPECTED;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     return ERR_UNEXPECTED;
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
+  virtual const BoundNetLog& NetLog() const override { return net_log_; }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE { return false; }
-  virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override { return false; }
+  virtual void EnableTCPFastOpenIfSupported() override {
     use_tcp_fastopen_ = true;
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
+  virtual bool WasNpnNegotiated() const override { return false; }
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
+  virtual int SetReceiveBufferSize(int32 size) override { return OK; }
+  virtual int SetSendBufferSize(int32 size) override { return OK; }
 
  private:
   const AddressList addrlist_;
@@ -211,21 +211,21 @@
   }
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     DCHECK(callback_.is_null());
     callback_ = callback;
     return ERR_IO_PENDING;
   }
 
-  virtual void Disconnect() OVERRIDE {}
+  virtual void Disconnect() override {}
 
-  virtual bool IsConnected() const OVERRIDE { return is_connected_; }
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return is_connected_; }
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual bool IsConnected() const override { return is_connected_; }
+  virtual bool IsConnectedAndIdle() const override { return is_connected_; }
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     *address = addrlist_.front();
     return OK;
   }
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     if (!is_connected_)
       return ERR_SOCKET_NOT_CONNECTED;
     if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4)
@@ -234,35 +234,35 @@
       SetIPv6Address(address);
     return OK;
   }
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
+  virtual const BoundNetLog& NetLog() const override { return net_log_; }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE {}
-  virtual void SetOmniboxSpeculation() OVERRIDE {}
-  virtual bool WasEverUsed() const OVERRIDE { return false; }
-  virtual void EnableTCPFastOpenIfSupported() OVERRIDE {
+  virtual void SetSubresourceSpeculation() override {}
+  virtual void SetOmniboxSpeculation() override {}
+  virtual bool WasEverUsed() const override { return false; }
+  virtual void EnableTCPFastOpenIfSupported() override {
     use_tcp_fastopen_ = true;
   }
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return use_tcp_fastopen_; }
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override { return use_tcp_fastopen_; }
+  virtual bool WasNpnNegotiated() const override { return false; }
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
+  virtual int SetReceiveBufferSize(int32 size) override { return OK; }
+  virtual int SetSendBufferSize(int32 size) override { return OK; }
 
  private:
   void DoCallback() {
diff --git a/net/socket/transport_client_socket_pool_test_util.h b/net/socket/transport_client_socket_pool_test_util.h
index 40ed1d1..b4adb71 100644
--- a/net/socket/transport_client_socket_pool_test_util.h
+++ b/net/socket/transport_client_socket_pool_test_util.h
@@ -73,20 +73,20 @@
       DatagramSocket::BindType bind_type,
       const RandIntCallback& rand_int_cb,
       NetLog* net_log,
-      const NetLog::Source& source) OVERRIDE;
+      const NetLog::Source& source) override;
 
   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
       const AddressList& addresses,
       NetLog* /* net_log */,
-      const NetLog::Source& /* source */) OVERRIDE;
+      const NetLog::Source& /* source */) override;
 
   virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
       scoped_ptr<ClientSocketHandle> transport_socket,
       const HostPortPair& host_and_port,
       const SSLConfig& ssl_config,
-      const SSLClientSocketContext& context) OVERRIDE;
+      const SSLClientSocketContext& context) override;
 
-  virtual void ClearSSLSessionCache() OVERRIDE;
+  virtual void ClearSSLSessionCache() override;
 
   int allocation_count() const { return allocation_count_; }
 
diff --git a/net/socket/transport_client_socket_unittest.cc b/net/socket/transport_client_socket_unittest.cc
index 5548b27..8bfb674 100644
--- a/net/socket/transport_client_socket_unittest.cc
+++ b/net/socket/transport_client_socket_unittest.cc
@@ -48,18 +48,18 @@
 
   // Implement StreamListenSocket::Delegate methods
   virtual void DidAccept(StreamListenSocket* server,
-                         scoped_ptr<StreamListenSocket> connection) OVERRIDE {
+                         scoped_ptr<StreamListenSocket> connection) override {
     connected_sock_.reset(
         static_cast<TCPListenSocket*>(connection.release()));
   }
-  virtual void DidRead(StreamListenSocket*, const char* str, int len) OVERRIDE {
+  virtual void DidRead(StreamListenSocket*, const char* str, int len) override {
     // TODO(dkegel): this might not be long enough to tickle some bugs.
     connected_sock_->Send(kServerReply, arraysize(kServerReply) - 1,
                           false /* Don't append line feed */);
     if (close_server_socket_on_next_send_)
       CloseServerSocket();
   }
-  virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
+  virtual void DidClose(StreamListenSocket* sock) override {}
 
   // Testcase hooks
   virtual void SetUp();
diff --git a/net/socket/unix_domain_client_socket_posix.h b/net/socket/unix_domain_client_socket_posix.h
index d6f2445..e70694a 100644
--- a/net/socket/unix_domain_client_socket_posix.h
+++ b/net/socket/unix_domain_client_socket_posix.h
@@ -41,28 +41,28 @@
                           SockaddrStorage* address);
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
 
   // Releases ownership of underlying SocketDescriptor to caller.
   // Internal state is reset so that this object can be used again.
diff --git a/net/socket/unix_domain_listen_socket_posix.h b/net/socket/unix_domain_listen_socket_posix.h
index bbdbf5f..8b9ba8e 100644
--- a/net/socket/unix_domain_listen_socket_posix.h
+++ b/net/socket/unix_domain_listen_socket_posix.h
@@ -64,7 +64,7 @@
       bool use_abstract_namespace);
 
   // StreamListenSocket:
-  virtual void Accept() OVERRIDE;
+  virtual void Accept() override;
 
   AuthCallback auth_callback_;
 
@@ -83,7 +83,7 @@
 
   // StreamListenSocketFactory:
   virtual scoped_ptr<StreamListenSocket> CreateAndListen(
-      StreamListenSocket::Delegate* delegate) const OVERRIDE;
+      StreamListenSocket::Delegate* delegate) const override;
 
  protected:
   const std::string path_;
@@ -107,7 +107,7 @@
 
   // UnixDomainListenSocketFactory:
   virtual scoped_ptr<StreamListenSocket> CreateAndListen(
-      StreamListenSocket::Delegate* delegate) const OVERRIDE;
+      StreamListenSocket::Delegate* delegate) const override;
 
  private:
   std::string fallback_path_;
diff --git a/net/socket/unix_domain_listen_socket_posix_unittest.cc b/net/socket/unix_domain_listen_socket_posix_unittest.cc
index 117c5c5..bea60c6 100644
--- a/net/socket/unix_domain_listen_socket_posix_unittest.cc
+++ b/net/socket/unix_domain_listen_socket_posix_unittest.cc
@@ -95,7 +95,7 @@
       : event_manager_(event_manager) {}
 
   virtual void DidAccept(StreamListenSocket* server,
-                         scoped_ptr<StreamListenSocket> connection) OVERRIDE {
+                         scoped_ptr<StreamListenSocket> connection) override {
     LOG(ERROR) << __PRETTY_FUNCTION__;
     connection_ = connection.Pass();
     Notify(EVENT_ACCEPT);
@@ -103,7 +103,7 @@
 
   virtual void DidRead(StreamListenSocket* connection,
                        const char* data,
-                       int len) OVERRIDE {
+                       int len) override {
     {
       base::AutoLock lock(mutex_);
       DCHECK(len);
@@ -112,7 +112,7 @@
     Notify(EVENT_READ);
   }
 
-  virtual void DidClose(StreamListenSocket* sock) OVERRIDE {
+  virtual void DidClose(StreamListenSocket* sock) override {
     Notify(EVENT_CLOSE);
   }
 
@@ -169,12 +169,12 @@
     return temp_dir_.path().Append(socket_name);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     event_manager_ = new EventManager();
     socket_delegate_.reset(new TestListenSocketDelegate(event_manager_));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     socket_.reset();
     socket_delegate_.reset();
     event_manager_ = NULL;
diff --git a/net/socket/unix_domain_server_socket_posix.h b/net/socket/unix_domain_server_socket_posix.h
index 65b3fa1..8fd8b34 100644
--- a/net/socket/unix_domain_server_socket_posix.h
+++ b/net/socket/unix_domain_server_socket_posix.h
@@ -51,13 +51,13 @@
                                  Credentials* credentials);
 
   // ServerSocket implementation.
-  virtual int Listen(const IPEndPoint& address, int backlog) OVERRIDE;
+  virtual int Listen(const IPEndPoint& address, int backlog) override;
   virtual int ListenWithAddressAndPort(const std::string& unix_domain_path,
                                        int port_unused,
-                                       int backlog) OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+                                       int backlog) override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
   virtual int Accept(scoped_ptr<StreamSocket>* socket,
-                     const CompletionCallback& callback) OVERRIDE;
+                     const CompletionCallback& callback) override;
 
   // Accepts an incoming connection on |listen_socket_|, but passes back
   // a raw SocketDescriptor instead of a StreamSocket.
diff --git a/net/socket/websocket_endpoint_lock_manager_unittest.cc b/net/socket/websocket_endpoint_lock_manager_unittest.cc
index cfc6cc6..cafd1aa 100644
--- a/net/socket/websocket_endpoint_lock_manager_unittest.cc
+++ b/net/socket/websocket_endpoint_lock_manager_unittest.cc
@@ -22,57 +22,57 @@
   FakeStreamSocket() {}
 
   // StreamSocket implementation
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
-  virtual void Disconnect() OVERRIDE { return; }
+  virtual void Disconnect() override { return; }
 
-  virtual bool IsConnected() const OVERRIDE { return false; }
+  virtual bool IsConnected() const override { return false; }
 
-  virtual bool IsConnectedAndIdle() const OVERRIDE { return false; }
+  virtual bool IsConnectedAndIdle() const override { return false; }
 
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetPeerAddress(IPEndPoint* address) const override {
     return ERR_FAILED;
   }
 
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
+  virtual int GetLocalAddress(IPEndPoint* address) const override {
     return ERR_FAILED;
   }
 
-  virtual const BoundNetLog& NetLog() const OVERRIDE { return bound_net_log_; }
+  virtual const BoundNetLog& NetLog() const override { return bound_net_log_; }
 
-  virtual void SetSubresourceSpeculation() OVERRIDE { return; }
-  virtual void SetOmniboxSpeculation() OVERRIDE { return; }
+  virtual void SetSubresourceSpeculation() override { return; }
+  virtual void SetOmniboxSpeculation() override { return; }
 
-  virtual bool WasEverUsed() const OVERRIDE { return false; }
+  virtual bool WasEverUsed() const override { return false; }
 
-  virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
+  virtual bool UsingTCPFastOpen() const override { return false; }
 
-  virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
+  virtual bool WasNpnNegotiated() const override { return false; }
 
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
 
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override { return false; }
 
   // Socket implementation
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_FAILED;
   }
 
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return ERR_FAILED; }
+  virtual int SetReceiveBufferSize(int32 size) override { return ERR_FAILED; }
 
-  virtual int SetSendBufferSize(int32 size) OVERRIDE { return ERR_FAILED; }
+  virtual int SetSendBufferSize(int32 size) override { return ERR_FAILED; }
 
  private:
   BoundNetLog bound_net_log_;
@@ -84,7 +84,7 @@
  public:
   FakeWaiter() : called_(false) {}
 
-  virtual void GotEndpointLock() OVERRIDE {
+  virtual void GotEndpointLock() override {
     CHECK(!called_);
     called_ = true;
   }
diff --git a/net/socket/websocket_transport_client_socket_pool.h b/net/socket/websocket_transport_client_socket_pool.h
index 74b8f78..e918354 100644
--- a/net/socket/websocket_transport_client_socket_pool.h
+++ b/net/socket/websocket_transport_client_socket_pool.h
@@ -65,7 +65,7 @@
   const BoundNetLog& request_net_log() const { return request_net_log_; }
 
   // ConnectJob methods.
-  virtual LoadState GetLoadState() const OVERRIDE;
+  virtual LoadState GetLoadState() const override;
 
  private:
   friend class WebSocketTransportConnectSubJob;
@@ -90,7 +90,7 @@
   // Begins the host resolution and the TCP connect.  Returns OK on success
   // and ERR_IO_PENDING if it cannot immediately service the request.
   // Otherwise, it returns a net error code.
-  virtual int ConnectInternal() OVERRIDE;
+  virtual int ConnectInternal() override;
 
   TransportConnectJobHelper helper_;
 
@@ -138,33 +138,33 @@
                             RequestPriority priority,
                             ClientSocketHandle* handle,
                             const CompletionCallback& callback,
-                            const BoundNetLog& net_log) OVERRIDE;
+                            const BoundNetLog& net_log) override;
   virtual void RequestSockets(const std::string& group_name,
                               const void* params,
                               int num_sockets,
-                              const BoundNetLog& net_log) OVERRIDE;
+                              const BoundNetLog& net_log) override;
   virtual void CancelRequest(const std::string& group_name,
-                             ClientSocketHandle* handle) OVERRIDE;
+                             ClientSocketHandle* handle) override;
   virtual void ReleaseSocket(const std::string& group_name,
                              scoped_ptr<StreamSocket> socket,
-                             int id) OVERRIDE;
-  virtual void FlushWithError(int error) OVERRIDE;
-  virtual void CloseIdleSockets() OVERRIDE;
-  virtual int IdleSocketCount() const OVERRIDE;
+                             int id) override;
+  virtual void FlushWithError(int error) override;
+  virtual void CloseIdleSockets() override;
+  virtual int IdleSocketCount() const override;
   virtual int IdleSocketCountInGroup(
-      const std::string& group_name) const OVERRIDE;
+      const std::string& group_name) const override;
   virtual LoadState GetLoadState(
       const std::string& group_name,
-      const ClientSocketHandle* handle) const OVERRIDE;
+      const ClientSocketHandle* handle) const override;
   virtual base::DictionaryValue* GetInfoAsValue(
       const std::string& name,
       const std::string& type,
-      bool include_nested_pools) const OVERRIDE;
-  virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
-  virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
+      bool include_nested_pools) const override;
+  virtual base::TimeDelta ConnectionTimeout() const override;
+  virtual ClientSocketPoolHistograms* histograms() const override;
 
   // HigherLayeredPool implementation.
-  virtual bool IsStalled() const OVERRIDE;
+  virtual bool IsStalled() const override;
 
  private:
   class ConnectJobDelegate : public ConnectJob::Delegate {
@@ -172,7 +172,7 @@
     explicit ConnectJobDelegate(WebSocketTransportClientSocketPool* owner);
     virtual ~ConnectJobDelegate();
 
-    virtual void OnConnectJobComplete(int result, ConnectJob* job) OVERRIDE;
+    virtual void OnConnectJobComplete(int result, ConnectJob* job) override;
 
    private:
     WebSocketTransportClientSocketPool* owner_;
diff --git a/net/socket/websocket_transport_connect_sub_job.h b/net/socket/websocket_transport_connect_sub_job.h
index 79980d2..e6f81e8 100644
--- a/net/socket/websocket_transport_connect_sub_job.h
+++ b/net/socket/websocket_transport_connect_sub_job.h
@@ -47,7 +47,7 @@
   scoped_ptr<StreamSocket> PassSocket() { return transport_socket_.Pass(); }
 
   // Implementation of WebSocketEndpointLockManager::EndpointWaiter.
-  virtual void GotEndpointLock() OVERRIDE;
+  virtual void GotEndpointLock() override;
 
  private:
   enum State {
diff --git a/net/socket_stream/socket_stream_unittest.cc b/net/socket_stream/socket_stream_unittest.cc
index 069f92e..7c4b50e 100644
--- a/net/socket_stream/socket_stream_unittest.cc
+++ b/net/socket_stream/socket_stream_unittest.cc
@@ -90,7 +90,7 @@
 
   virtual int OnStartOpenConnection(
       SocketStream* socket,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     connection_callback_ = callback;
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_START_OPEN_CONNECTION,
@@ -100,7 +100,7 @@
     return OK;
   }
   virtual void OnConnected(SocketStream* socket,
-                           int num_pending_send_allowed) OVERRIDE {
+                           int num_pending_send_allowed) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_CONNECTED,
                           socket, num_pending_send_allowed, std::string(),
@@ -109,7 +109,7 @@
       on_connected_.Run(&events_.back());
   }
   virtual void OnSentData(SocketStream* socket,
-                          int amount_sent) OVERRIDE {
+                          int amount_sent) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_SENT_DATA, socket,
                           amount_sent, std::string(), NULL, OK));
@@ -117,14 +117,14 @@
       on_sent_data_.Run(&events_.back());
   }
   virtual void OnReceivedData(SocketStream* socket,
-                              const char* data, int len) OVERRIDE {
+                              const char* data, int len) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_RECEIVED_DATA, socket, len,
                           std::string(data, len), NULL, OK));
     if (!on_received_data_.is_null())
       on_received_data_.Run(&events_.back());
   }
-  virtual void OnClose(SocketStream* socket) OVERRIDE {
+  virtual void OnClose(SocketStream* socket) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_CLOSE, socket, 0,
                           std::string(), NULL, OK));
@@ -134,14 +134,14 @@
       callback_.Run(OK);
   }
   virtual void OnAuthRequired(SocketStream* socket,
-                              AuthChallengeInfo* auth_info) OVERRIDE {
+                              AuthChallengeInfo* auth_info) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_AUTH_REQUIRED, socket, 0,
                           std::string(), auth_info, OK));
     if (!on_auth_required_.is_null())
       on_auth_required_.Run(&events_.back());
   }
-  virtual void OnError(const SocketStream* socket, int error) OVERRIDE {
+  virtual void OnError(const SocketStream* socket, int error) override {
     events_.push_back(
         SocketStreamEvent(SocketStreamEvent::EVENT_ERROR, NULL, 0,
                           std::string(), NULL, error));
@@ -198,7 +198,7 @@
   virtual ~SelfDeletingDelegate() {}
 
   // Call DetachDelegate(), delete |this|, then run the callback.
-  virtual void OnError(const SocketStream* socket, int error) OVERRIDE {
+  virtual void OnError(const SocketStream* socket, int error) override {
     // callback_ will be deleted when we delete |this|, so copy it to call it
     // afterwards.
     CompletionCallback callback = callback_;
@@ -215,17 +215,17 @@
   }
 
   virtual void OnConnected(SocketStream* socket, int max_pending_send_allowed)
-      OVERRIDE {
+      override {
     ADD_FAILURE() << "OnConnected() should not be called";
   }
-  virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE {
+  virtual void OnSentData(SocketStream* socket, int amount_sent) override {
     ADD_FAILURE() << "OnSentData() should not be called";
   }
   virtual void OnReceivedData(SocketStream* socket, const char* data, int len)
-      OVERRIDE {
+      override {
     ADD_FAILURE() << "OnReceivedData() should not be called";
   }
-  virtual void OnClose(SocketStream* socket) OVERRIDE {
+  virtual void OnClose(SocketStream* socket) override {
     ADD_FAILURE() << "OnClose() should not be called";
   }
 
@@ -254,7 +254,7 @@
 
   virtual int OnBeforeSocketStreamConnect(
       SocketStream* stream,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     return before_connect_result_;
   }
 
diff --git a/net/spdy/buffered_spdy_framer.h b/net/spdy/buffered_spdy_framer.h
index 426bc5f..fba98d7 100644
--- a/net/spdy/buffered_spdy_framer.h
+++ b/net/spdy/buffered_spdy_framer.h
@@ -135,41 +135,41 @@
   void set_debug_visitor(SpdyFramerDebugVisitorInterface* debug_visitor);
 
   // SpdyFramerVisitorInterface
-  virtual void OnError(SpdyFramer* spdy_framer) OVERRIDE;
+  virtual void OnError(SpdyFramer* spdy_framer) override;
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
-                           bool unidirectional) OVERRIDE;
-  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE;
-  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE;
+                           bool unidirectional) override;
+  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) override;
+  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override;
   virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                         const char* header_data,
-                                        size_t len) OVERRIDE;
+                                        size_t len) override;
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
-                                 bool fin) OVERRIDE;
-  virtual void OnSettings(bool clear_persisted) OVERRIDE;
+                                 bool fin) override;
+  virtual void OnSettings(bool clear_persisted) override;
   virtual void OnSetting(
-      SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE;
-  virtual void OnSettingsAck() OVERRIDE;
-  virtual void OnSettingsEnd() OVERRIDE;
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE;
+      SpdySettingsIds id, uint8 flags, uint32 value) override;
+  virtual void OnSettingsAck() override;
+  virtual void OnSettingsEnd() override;
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override;
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE;
+                           SpdyRstStreamStatus status) override;
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE;
+                        SpdyGoAwayStatus status) override;
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) OVERRIDE;
+                              uint32 delta_window_size) override;
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
-                             bool end) OVERRIDE;
+                             bool end) override;
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
-                                 bool fin) OVERRIDE;
-  virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE;
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE;
+                                 bool fin) override;
+  virtual void OnContinuation(SpdyStreamId stream_id, bool end) override;
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override;
 
   // SpdyFramer methods.
   size_t ProcessInput(const char* data, size_t len);
diff --git a/net/spdy/buffered_spdy_framer_unittest.cc b/net/spdy/buffered_spdy_framer_unittest.cc
index 3e106f9..0fc758b 100644
--- a/net/spdy/buffered_spdy_framer_unittest.cc
+++ b/net/spdy/buffered_spdy_framer_unittest.cc
@@ -25,14 +25,14 @@
         promised_stream_id_(static_cast<SpdyStreamId>(-1)) {
   }
 
-  virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {
+  virtual void OnError(SpdyFramer::SpdyError error_code) override {
     LOG(INFO) << "SpdyFramer Error: " << error_code;
     error_count_++;
   }
 
   virtual void OnStreamError(
       SpdyStreamId stream_id,
-      const std::string& description) OVERRIDE {
+      const std::string& description) override {
     LOG(INFO) << "SpdyFramer Error on stream: " << stream_id  << " "
               << description;
     error_count_++;
@@ -43,7 +43,7 @@
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional,
-                           const SpdyHeaderBlock& headers) OVERRIDE {
+                           const SpdyHeaderBlock& headers) override {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     syn_frame_count_++;
@@ -52,7 +52,7 @@
 
   virtual void OnSynReply(SpdyStreamId stream_id,
                           bool fin,
-                          const SpdyHeaderBlock& headers) OVERRIDE {
+                          const SpdyHeaderBlock& headers) override {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     syn_reply_frame_count_++;
@@ -61,7 +61,7 @@
 
   virtual void OnHeaders(SpdyStreamId stream_id,
                          bool fin,
-                         const SpdyHeaderBlock& headers) OVERRIDE {
+                         const SpdyHeaderBlock& headers) override {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     headers_frame_count_++;
@@ -70,33 +70,33 @@
 
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
-                                 bool fin) OVERRIDE {
+                                 bool fin) override {
     ADD_FAILURE() << "Unexpected OnDataFrameHeader call.";
   }
 
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
-                                 bool fin) OVERRIDE {
+                                 bool fin) override {
     LOG(FATAL) << "Unexpected OnStreamFrameData call.";
   }
 
-  virtual void OnSettings(bool clear_persisted) OVERRIDE {}
+  virtual void OnSettings(bool clear_persisted) override {}
 
   virtual void OnSetting(SpdySettingsIds id,
                          uint8 flags,
-                         uint32 value) OVERRIDE {
+                         uint32 value) override {
     setting_count_++;
   }
 
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {}
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {}
 
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE {
+                           SpdyRstStreamStatus status) override {
   }
 
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE {
+                        SpdyGoAwayStatus status) override {
   }
 
   bool OnCredentialFrameData(const char*, size_t) {
@@ -112,11 +112,11 @@
   void OnGoAway(const SpdyFrame& frame) {}
   void OnPing(const SpdyFrame& frame) {}
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) OVERRIDE {}
+                              uint32 delta_window_size) override {}
 
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
-                             const SpdyHeaderBlock& headers) OVERRIDE {
+                             const SpdyHeaderBlock& headers) override {
     header_stream_id_ = stream_id;
     EXPECT_NE(header_stream_id_, SpdyFramer::kInvalidStream);
     push_promise_frame_count_++;
@@ -125,7 +125,7 @@
     headers_ = headers;
   }
 
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE {
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
     return true;
   }
 
diff --git a/net/spdy/spdy_buffer_producer.h b/net/spdy/spdy_buffer_producer.h
index fe82b1a..d8777af 100644
--- a/net/spdy/spdy_buffer_producer.h
+++ b/net/spdy/spdy_buffer_producer.h
@@ -37,7 +37,7 @@
 
   virtual ~SimpleBufferProducer();
 
-  virtual scoped_ptr<SpdyBuffer> ProduceBuffer() OVERRIDE;
+  virtual scoped_ptr<SpdyBuffer> ProduceBuffer() override;
 
  private:
   scoped_ptr<SpdyBuffer> buffer_;
diff --git a/net/spdy/spdy_frame_builder.cc b/net/spdy/spdy_frame_builder.cc
index b491e8b..0b85211 100644
--- a/net/spdy/spdy_frame_builder.cc
+++ b/net/spdy/spdy_frame_builder.cc
@@ -63,8 +63,8 @@
                                                SpdyFrameType type,
                                                uint8 flags) {
   DCHECK_GE(SPDY3, version_);
-  DCHECK_NE(-1,
-            SpdyConstants::SerializeFrameType(version_, type));
+  DCHECK(SpdyConstants::IsValidFrameType(
+      version_, SpdyConstants::SerializeFrameType(version_, type)));
   bool success = true;
   FlagsAndLength flags_length = CreateFlagsAndLength(
       flags, capacity_ - framer.GetControlFrameHeaderSize());
@@ -101,10 +101,10 @@
                                      SpdyFrameType type,
                                      uint8 flags,
                                      SpdyStreamId stream_id) {
-  DCHECK(SpdyConstants::IsValidFrameType(version_,
-      SpdyConstants::SerializeFrameType(version_, type)));
+  DCHECK(SpdyConstants::IsValidFrameType(
+      version_, SpdyConstants::SerializeFrameType(version_, type)));
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
-  DCHECK_LT(SPDY3, framer.protocol_version());
+  DCHECK_GT(framer.protocol_version(), SPDY3);
   bool success = true;
   if (length_ > 0) {
     // Update length field for previous frame.
@@ -136,7 +136,7 @@
     return false;
   }
 
-  if (!WriteUInt16(static_cast<int>(value.size())))
+  if (!WriteUInt16(static_cast<uint16>(value.size())))
     return false;
 
   return WriteBytes(value.data(), static_cast<uint16>(value.size()));
@@ -168,17 +168,17 @@
 
 bool SpdyFrameBuilder::OverwriteLength(const SpdyFramer& framer,
                                        size_t length) {
-  if (version_ <= SPDY3) {
-    DCHECK_GE(SpdyConstants::GetFrameMaximumSize(version_) -
-              framer.GetFrameMinimumSize(),
-              length);
+  if (version_ < SPDY4) {
+    DCHECK_LE(length,
+              SpdyConstants::GetFrameMaximumSize(version_) -
+                  framer.GetFrameMinimumSize());
   } else {
-    DCHECK_GE(SpdyConstants::GetFrameMaximumSize(version_), length);
+    DCHECK_LE(length, SpdyConstants::GetFrameMaximumSize(version_));
   }
   bool success = false;
   const size_t old_length = length_;
 
-  if (version_ <= SPDY3) {
+  if (version_ < SPDY4) {
     FlagsAndLength flags_length = CreateFlagsAndLength(
         0,  // We're not writing over the flags value anyway.
         length);
@@ -198,7 +198,7 @@
 
 bool SpdyFrameBuilder::OverwriteFlags(const SpdyFramer& framer,
                                       uint8 flags) {
-  DCHECK_LT(SPDY3, framer.protocol_version());
+  DCHECK_GT(framer.protocol_version(), SPDY3);
   bool success = false;
   const size_t old_length = length_;
   // Flags are the fifth octet in the frame prefix.
diff --git a/net/spdy/spdy_framer.cc b/net/spdy/spdy_framer.cc
index edcc82e..fbe3675 100644
--- a/net/spdy/spdy_framer.cc
+++ b/net/spdy/spdy_framer.cc
@@ -675,15 +675,15 @@
       new SpdyFrameReader(current_frame_buffer_.get(),
                           current_frame_buffer_length_));
 
-  uint16 version = 0;
   bool is_control_frame = false;
 
   uint16 control_frame_type_field =
-    SpdyConstants::DataFrameType(protocol_version());
+      SpdyConstants::DataFrameType(protocol_version());
   // ProcessControlFrameHeader() will set current_frame_type_ to the
   // correct value if this is a valid control frame.
   current_frame_type_ = DATA;
   if (protocol_version() <= SPDY3) {
+    uint16 version = 0;
     bool successful_read = reader->ReadUInt16(&version);
     DCHECK(successful_read);
     is_control_frame = (version & kControlFlagMask) != 0;
@@ -700,9 +700,6 @@
                  << " (expected " << protocol_version() << ")";
         set_error(SPDY_UNSUPPORTED_VERSION);
         return 0;
-      } else {
-        // Convert version from wire format to SpdyMajorVersion.
-        version = SpdyConstants::ParseMajorVersion(version);
       }
       // We check control_frame_type_field's validity in
       // ProcessControlFrameHeader().
@@ -722,7 +719,6 @@
     remaining_data_length_ = length_field;
     current_frame_length_ = remaining_data_length_ + reader->GetBytesConsumed();
   } else {
-    version = protocol_version();
     uint32 length_field = 0;
     bool successful_read = reader->ReadUInt24(&length_field);
     DCHECK(successful_read);
@@ -1173,9 +1169,9 @@
                                   const SpdyMajorVersion spdy_version,
                                   const SpdyHeaderBlock* headers) {
   if (spdy_version < SPDY3) {
-    frame->WriteUInt16(headers->size());  // Number of headers.
+    frame->WriteUInt16(headers->size());
   } else {
-    frame->WriteUInt32(headers->size());  // Number of headers.
+    frame->WriteUInt32(headers->size());
   }
   SpdyHeaderBlock::const_iterator it;
   for (it = headers->begin(); it != headers->end(); ++it) {
@@ -2847,49 +2843,49 @@
 
   SpdySerializedFrame* ReleaseSerializedFrame() { return frame_.release(); }
 
-  virtual void VisitData(const SpdyDataIR& data) OVERRIDE {
+  virtual void VisitData(const SpdyDataIR& data) override {
     frame_.reset(framer_->SerializeData(data));
   }
-  virtual void VisitSynStream(const SpdySynStreamIR& syn_stream) OVERRIDE {
+  virtual void VisitSynStream(const SpdySynStreamIR& syn_stream) override {
     frame_.reset(framer_->SerializeSynStream(syn_stream));
   }
-  virtual void VisitSynReply(const SpdySynReplyIR& syn_reply) OVERRIDE {
+  virtual void VisitSynReply(const SpdySynReplyIR& syn_reply) override {
     frame_.reset(framer_->SerializeSynReply(syn_reply));
   }
-  virtual void VisitRstStream(const SpdyRstStreamIR& rst_stream) OVERRIDE {
+  virtual void VisitRstStream(const SpdyRstStreamIR& rst_stream) override {
     frame_.reset(framer_->SerializeRstStream(rst_stream));
   }
-  virtual void VisitSettings(const SpdySettingsIR& settings) OVERRIDE {
+  virtual void VisitSettings(const SpdySettingsIR& settings) override {
     frame_.reset(framer_->SerializeSettings(settings));
   }
-  virtual void VisitPing(const SpdyPingIR& ping) OVERRIDE {
+  virtual void VisitPing(const SpdyPingIR& ping) override {
     frame_.reset(framer_->SerializePing(ping));
   }
-  virtual void VisitGoAway(const SpdyGoAwayIR& goaway) OVERRIDE {
+  virtual void VisitGoAway(const SpdyGoAwayIR& goaway) override {
     frame_.reset(framer_->SerializeGoAway(goaway));
   }
-  virtual void VisitHeaders(const SpdyHeadersIR& headers) OVERRIDE {
+  virtual void VisitHeaders(const SpdyHeadersIR& headers) override {
     frame_.reset(framer_->SerializeHeaders(headers));
   }
   virtual void VisitWindowUpdate(
-      const SpdyWindowUpdateIR& window_update) OVERRIDE {
+      const SpdyWindowUpdateIR& window_update) override {
     frame_.reset(framer_->SerializeWindowUpdate(window_update));
   }
-  virtual void VisitBlocked(const SpdyBlockedIR& blocked) OVERRIDE {
+  virtual void VisitBlocked(const SpdyBlockedIR& blocked) override {
     frame_.reset(framer_->SerializeBlocked(blocked));
   }
   virtual void VisitPushPromise(
-      const SpdyPushPromiseIR& push_promise) OVERRIDE {
+      const SpdyPushPromiseIR& push_promise) override {
     frame_.reset(framer_->SerializePushPromise(push_promise));
   }
   virtual void VisitContinuation(
-      const SpdyContinuationIR& continuation) OVERRIDE {
+      const SpdyContinuationIR& continuation) override {
     frame_.reset(framer_->SerializeContinuation(continuation));
   }
-  virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) OVERRIDE {
+  virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) override {
     frame_.reset(framer_->SerializeAltSvc(altsvc));
   }
-  virtual void VisitPriority(const SpdyPriorityIR& priority) OVERRIDE {
+  virtual void VisitPriority(const SpdyPriorityIR& priority) override {
     frame_.reset(framer_->SerializePriority(priority));
   }
 
diff --git a/net/spdy/spdy_framer_test.cc b/net/spdy/spdy_framer_test.cc
index 2676b4d..07b23ac 100644
--- a/net/spdy/spdy_framer_test.cc
+++ b/net/spdy/spdy_framer_test.cc
@@ -82,22 +82,22 @@
       buffer_.reset(new char[kMaxDecompressedSize]);
     }
 
-    virtual void OnError(SpdyFramer* framer) OVERRIDE { LOG(FATAL); }
+    virtual void OnError(SpdyFramer* framer) override { LOG(FATAL); }
     virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                    size_t length,
-                                   bool fin) OVERRIDE {
+                                   bool fin) override {
       LOG(FATAL) << "Unexpected data frame header";
     }
     virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                    const char* data,
                                    size_t len,
-                                   bool fin) OVERRIDE {
+                                   bool fin) override {
       LOG(FATAL);
     }
 
     virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                           const char* header_data,
-                                          size_t len) OVERRIDE {
+                                          size_t len) override {
       CHECK(buffer_.get() != NULL);
       CHECK_GE(kMaxDecompressedSize, size_ + len);
       CHECK(!finished_);
@@ -115,7 +115,7 @@
                              SpdyStreamId associated_stream_id,
                              SpdyPriority priority,
                              bool fin,
-                             bool unidirectional) OVERRIDE {
+                             bool unidirectional) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdySynStreamIR syn_stream(stream_id);
@@ -129,7 +129,7 @@
       size_ += framer.GetSynStreamMinimumSize();
     }
 
-    virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
+    virtual void OnSynReply(SpdyStreamId stream_id, bool fin) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyHeadersIR headers(stream_id);
@@ -141,26 +141,26 @@
     }
 
     virtual void OnRstStream(SpdyStreamId stream_id,
-                             SpdyRstStreamStatus status) OVERRIDE {
+                             SpdyRstStreamStatus status) override {
       LOG(FATAL);
     }
     virtual void OnSetting(SpdySettingsIds id,
                            uint8 flags,
-                           uint32 value) OVERRIDE {
+                           uint32 value) override {
       LOG(FATAL);
     }
-    virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
+    virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {
       LOG(FATAL);
     }
-    virtual void OnSettingsEnd() OVERRIDE { LOG(FATAL); }
+    virtual void OnSettingsEnd() override { LOG(FATAL); }
     virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                          SpdyGoAwayStatus status) OVERRIDE {
+                          SpdyGoAwayStatus status) override {
       LOG(FATAL);
     }
 
     virtual void OnHeaders(SpdyStreamId stream_id,
                            bool fin,
-                           bool end) OVERRIDE {
+                           bool end) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyHeadersIR headers(stream_id);
@@ -177,7 +177,7 @@
 
     virtual void OnPushPromise(SpdyStreamId stream_id,
                                SpdyStreamId promised_stream_id,
-                               bool end) OVERRIDE {
+                               bool end) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
@@ -187,19 +187,19 @@
       size_ += framer.GetPushPromiseMinimumSize();
     }
 
-    virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
+    virtual void OnContinuation(SpdyStreamId stream_id, bool end) override {
       LOG(FATAL);
     }
 
     virtual void OnPriority(SpdyStreamId stream_id,
                             SpdyStreamId parent_stream_id,
                             uint8 weight,
-                            bool exclusive) OVERRIDE {
+                            bool exclusive) override {
       // Do nothing.
     }
 
     virtual bool OnUnknownFrame(SpdyStreamId stream_id,
-                                int frame_type) OVERRIDE {
+                                int frame_type) override {
       LOG(FATAL);
       return false;
     }
@@ -210,7 +210,7 @@
     }
 
     virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                                uint32 delta_window_size) OVERRIDE {
+                                uint32 delta_window_size) override {
       LOG(FATAL);
     }
 
@@ -277,7 +277,7 @@
         header_control_type_(DATA),
         header_buffer_valid_(false) {}
 
-  virtual void OnError(SpdyFramer* f) OVERRIDE {
+  virtual void OnError(SpdyFramer* f) override {
     LOG(INFO) << "SpdyFramer Error: "
               << SpdyFramer::ErrorCodeToString(f->error_code());
     ++error_count_;
@@ -285,7 +285,7 @@
 
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
-                                 bool fin) OVERRIDE {
+                                 bool fin) override {
     ++data_frame_count_;
     header_stream_id_ = stream_id;
   }
@@ -293,7 +293,7 @@
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
-                                 bool fin) OVERRIDE {
+                                 bool fin) override {
     EXPECT_EQ(header_stream_id_, stream_id);
     if (len == 0)
       ++zero_length_data_frame_count_;
@@ -310,7 +310,7 @@
 
   virtual bool OnControlFrameHeaderData(SpdyStreamId stream_id,
                                         const char* header_data,
-                                        size_t len) OVERRIDE {
+                                        size_t len) override {
     ++control_frame_header_data_count_;
     CHECK_EQ(header_stream_id_, stream_id);
     if (len == 0) {
@@ -339,7 +339,7 @@
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
-                           bool unidirectional) OVERRIDE {
+                           bool unidirectional) override {
     ++syn_frame_count_;
     if (framer_.protocol_version() > SPDY3) {
       InitHeaderStreaming(HEADERS, stream_id);
@@ -351,7 +351,7 @@
     }
   }
 
-  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) OVERRIDE {
+  virtual void OnSynReply(SpdyStreamId stream_id, bool fin) override {
     ++syn_reply_frame_count_;
     if (framer_.protocol_version() > SPDY3) {
       InitHeaderStreaming(HEADERS, stream_id);
@@ -364,12 +364,12 @@
   }
 
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE {
+                           SpdyRstStreamStatus status) override {
     ++fin_frame_count_;
   }
 
   virtual bool OnRstStreamFrameData(const char* rst_stream_data,
-                                    size_t len) OVERRIDE {
+                                    size_t len) override {
     if ((rst_stream_data != NULL) && (len > 0)) {
       fin_opaque_data_ += std::string(rst_stream_data, len);
     }
@@ -378,30 +378,30 @@
 
   virtual void OnSetting(SpdySettingsIds id,
                          uint8 flags,
-                         uint32 value) OVERRIDE {
+                         uint32 value) override {
     ++setting_count_;
   }
 
-  virtual void OnSettingsAck() OVERRIDE {
+  virtual void OnSettingsAck() override {
     DCHECK_LT(SPDY3, framer_.protocol_version());
     ++settings_ack_received_;
   }
 
-  virtual void OnSettingsEnd() OVERRIDE {
+  virtual void OnSettingsEnd() override {
     if (framer_.protocol_version() <= SPDY3) { return; }
     ++settings_ack_sent_;
   }
 
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {
     DLOG(FATAL);
   }
 
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE {
+                        SpdyGoAwayStatus status) override {
     ++goaway_count_;
   }
 
-  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) OVERRIDE {
+  virtual void OnHeaders(SpdyStreamId stream_id, bool fin, bool end) override {
     ++headers_frame_count_;
     InitHeaderStreaming(HEADERS, stream_id);
     if (fin) {
@@ -410,21 +410,21 @@
   }
 
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) OVERRIDE {
+                              uint32 delta_window_size) override {
     last_window_update_stream_ = stream_id;
     last_window_update_delta_ = delta_window_size;
   }
 
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
-                             bool end) OVERRIDE {
+                             bool end) override {
     ++push_promise_frame_count_;
     InitHeaderStreaming(PUSH_PROMISE, stream_id);
     last_push_promise_stream_ = stream_id;
     last_push_promise_promised_stream_ = promised_stream_id;
   }
 
-  virtual void OnContinuation(SpdyStreamId stream_id, bool end) OVERRIDE {
+  virtual void OnContinuation(SpdyStreamId stream_id, bool end) override {
     ++continuation_count_;
   }
 
@@ -433,7 +433,7 @@
                         uint16 port,
                         StringPiece protocol_id,
                         StringPiece host,
-                        StringPiece origin) OVERRIDE {
+                        StringPiece origin) override {
     test_altsvc_ir_.set_stream_id(stream_id);
     test_altsvc_ir_.set_max_age(max_age);
     test_altsvc_ir_.set_port(port);
@@ -448,11 +448,11 @@
   virtual void OnPriority(SpdyStreamId stream_id,
                           SpdyStreamId parent_stream_id,
                           uint8 weight,
-                          bool exclusive) OVERRIDE {
+                          bool exclusive) override {
     ++priority_count_;
   }
 
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE {
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
     DLOG(INFO) << "Unknown frame type " << frame_type;
     return on_unknown_frame_result_;
   }
@@ -460,14 +460,14 @@
   virtual void OnSendCompressedFrame(SpdyStreamId stream_id,
                                      SpdyFrameType type,
                                      size_t payload_len,
-                                     size_t frame_len) OVERRIDE {
+                                     size_t frame_len) override {
     last_payload_len_ = payload_len;
     last_frame_len_ = frame_len;
   }
 
   virtual void OnReceiveCompressedFrame(SpdyStreamId stream_id,
                                         SpdyFrameType type,
-                                        size_t frame_len) OVERRIDE {
+                                        size_t frame_len) override {
     last_frame_len_ = frame_len;
   }
 
diff --git a/net/spdy/spdy_http_stream.h b/net/spdy/spdy_http_stream.h
index 0f37c66..fe3c87d 100644
--- a/net/spdy/spdy_http_stream.h
+++ b/net/spdy/spdy_http_stream.h
@@ -44,44 +44,44 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
 
   virtual int SendRequest(const HttpRequestHeaders& headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE;
-  virtual UploadProgress GetUploadProgress() const OVERRIDE;
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
+  virtual UploadProgress GetUploadProgress() const override;
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override;
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual void Close(bool not_reusable) OVERRIDE;
-  virtual HttpStream* RenewStreamForAuth() OVERRIDE;
-  virtual bool IsResponseBodyComplete() const OVERRIDE;
-  virtual bool CanFindEndOfResponse() const OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual void Close(bool not_reusable) override;
+  virtual HttpStream* RenewStreamForAuth() override;
+  virtual bool IsResponseBodyComplete() const override;
+  virtual bool CanFindEndOfResponse() const override;
 
   // Must not be called if a NULL SpdySession was pssed into the
   // constructor.
-  virtual bool IsConnectionReused() const OVERRIDE;
+  virtual bool IsConnectionReused() const override;
 
-  virtual void SetConnectionReused() OVERRIDE;
-  virtual bool IsConnectionReusable() const OVERRIDE;
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+  virtual void SetConnectionReused() override;
+  virtual bool IsConnectionReusable() const override;
+  virtual int64 GetTotalReceivedBytes() const override;
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override;
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
-  virtual bool IsSpdyHttpStream() const OVERRIDE;
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
+  virtual bool IsSpdyHttpStream() const override;
+  virtual void Drain(HttpNetworkSession* session) override;
+  virtual void SetPriority(RequestPriority priority) override;
 
   // SpdyStream::Delegate implementation.
-  virtual void OnRequestHeadersSent() OVERRIDE;
+  virtual void OnRequestHeadersSent() override;
   virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE;
-  virtual void OnDataSent() OVERRIDE;
-  virtual void OnClose(int status) OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
+  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override;
+  virtual void OnDataSent() override;
+  virtual void OnClose(int status) override;
 
  private:
   // Must be called only when |request_info_| is non-NULL.
diff --git a/net/spdy/spdy_http_stream_unittest.cc b/net/spdy/spdy_http_stream_unittest.cc
index f51133f..f1c1de2 100644
--- a/net/spdy/spdy_http_stream_unittest.cc
+++ b/net/spdy/spdy_http_stream_unittest.cc
@@ -14,10 +14,10 @@
 #include "crypto/ec_signature_creator.h"
 #include "crypto/signature_creator.h"
 #include "net/base/capturing_net_log.h"
+#include "net/base/chunked_upload_data_stream.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
-#include "net/base/upload_data_stream.h"
-#include "net/base/upload_element_reader.h"
+#include "net/base/test_completion_callback.h"
 #include "net/cert/asn1_util.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
@@ -79,7 +79,7 @@
   OrderedSocketData* data() { return data_.get(); }
 
  protected:
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     crypto::ECSignatureCreator::SetFactoryForTesting(NULL);
     base::MessageLoop::current()->RunUntilIdle();
   }
@@ -338,10 +338,10 @@
               key);
   EXPECT_EQ(spdy_util_.spdy_version(), session_->GetProtocolVersion());
 
-  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
+  ChunkedUploadDataStream upload_stream(0);
   const int kFirstChunkSize = kUploadDataSize/2;
-  upload_stream.AppendChunk(kUploadData, kFirstChunkSize, false);
-  upload_stream.AppendChunk(kUploadData + kFirstChunkSize,
+  upload_stream.AppendData(kUploadData, kFirstChunkSize, false);
+  upload_stream.AppendData(kUploadData + kFirstChunkSize,
                             kUploadDataSize - kFirstChunkSize, true);
 
   HttpRequestInfo request;
@@ -349,7 +349,7 @@
   request.url = GURL("http://www.google.com/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
+  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
 
   TestCompletionCallback callback;
   HttpResponseInfo response;
@@ -413,15 +413,15 @@
                            writes, arraysize(writes),
                            key);
 
-  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
+  ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
-  upload_stream.AppendChunk(kUploadData, kUploadDataSize, false);
+  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  upload_stream.AppendData(kUploadData, kUploadDataSize, false);
 
   BoundNetLog net_log;
   scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
@@ -443,8 +443,8 @@
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Now append the final two chunks which will enqueue two more writes.
-  upload_stream.AppendChunk(kUploadData1, kUploadData1Size, false);
-  upload_stream.AppendChunk(kUploadData, kUploadDataSize, true);
+  upload_stream.AppendData(kUploadData1, kUploadData1Size, false);
+  upload_stream.AppendData(kUploadData, kUploadDataSize, true);
 
   // Finish writing all the chunks.
   deterministic_data()->RunFor(2);
@@ -512,15 +512,15 @@
                            writes, arraysize(writes),
                            key);
 
-  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
+  ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
-  upload_stream.AppendChunk(kUploadData, kUploadDataSize, false);
+  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  upload_stream.AppendData(kUploadData, kUploadDataSize, false);
 
   BoundNetLog net_log;
   scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
@@ -542,7 +542,7 @@
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Now end the stream with an empty data frame and the FIN set.
-  upload_stream.AppendChunk(NULL, 0, true);
+  upload_stream.AppendData(NULL, 0, true);
 
   // Finish writing the final frame.
   deterministic_data()->RunFor(1);
@@ -597,15 +597,15 @@
                            writes, arraysize(writes),
                            key);
 
-  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
+  ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
-  upload_stream.AppendChunk("", 0, true);
+  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  upload_stream.AppendData("", 0, true);
 
   BoundNetLog net_log;
   scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
@@ -727,15 +727,15 @@
                            writes, arraysize(writes),
                            key);
 
-  UploadDataStream upload_stream(UploadDataStream::CHUNKED, 0);
+  ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data_stream = &upload_stream;
 
-  ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
-  upload_stream.AppendChunk(kUploadData, kUploadDataSize, true);
+  ASSERT_EQ(OK, upload_stream.Init(TestCompletionCallback().callback()));
+  upload_stream.AppendData(kUploadData, kUploadDataSize, true);
 
   BoundNetLog net_log;
   scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
diff --git a/net/spdy/spdy_network_transaction_unittest.cc b/net/spdy/spdy_network_transaction_unittest.cc
index 59a2f1b..92188ac 100644
--- a/net/spdy/spdy_network_transaction_unittest.cc
+++ b/net/spdy/spdy_network_transaction_unittest.cc
@@ -15,10 +15,11 @@
 #include "base/strings/string_piece.h"
 #include "base/test/test_file_util.h"
 #include "net/base/auth.h"
+#include "net/base/chunked_upload_data_stream.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_network_transaction.h"
@@ -120,7 +121,7 @@
   }
 
   virtual ~SpdyNetworkTransactionTest() {
-    // UploadDataStream posts deletion tasks back to the message loop on
+    // UploadDataStream may post a deletion tasks back to the message loop on
     // destruction.
     upload_data_stream_.reset();
     base::RunLoop().RunUntilIdle();
@@ -456,7 +457,7 @@
       element_readers.push_back(
           new UploadBytesElementReader(kUploadData, kUploadDataSize));
       upload_data_stream_.reset(
-          new UploadDataStream(element_readers.Pass(), 0));
+          new ElementsUploadDataStream(element_readers.Pass(), 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -481,7 +482,7 @@
                                       kUploadDataSize,
                                       base::Time()));
       upload_data_stream_.reset(
-          new UploadDataStream(element_readers.Pass(), 0));
+          new ElementsUploadDataStream(element_readers.Pass(), 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -509,7 +510,7 @@
                                     kUploadDataSize,
                                     base::Time()));
     upload_data_stream_.reset(
-        new UploadDataStream(element_readers.Pass(), 0));
+        new ElementsUploadDataStream(element_readers.Pass(), 0));
 
     google_post_request_.method = "POST";
     google_post_request_.url = GURL(kDefaultURL);
@@ -542,7 +543,7 @@
           kUploadData + kFileRangeOffset + kFileRangeLength,
           kUploadDataSize - (kFileRangeOffset + kFileRangeLength)));
       upload_data_stream_.reset(
-          new UploadDataStream(element_readers.Pass(), 0));
+          new ElementsUploadDataStream(element_readers.Pass(), 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
@@ -554,12 +555,11 @@
 
   const HttpRequestInfo& CreateChunkedPostRequest() {
     if (!google_chunked_post_request_initialized_) {
-      upload_data_stream_.reset(
-          new UploadDataStream(UploadDataStream::CHUNKED, 0));
+      upload_chunked_data_stream_.reset(new ChunkedUploadDataStream(0));
       google_chunked_post_request_.method = "POST";
       google_chunked_post_request_.url = GURL(kDefaultURL);
       google_chunked_post_request_.upload_data_stream =
-          upload_data_stream_.get();
+          upload_chunked_data_stream_.get();
       google_chunked_post_request_initialized_ = true;
     }
     return google_chunked_post_request_;
@@ -688,9 +688,14 @@
     callback.WaitForResult();
   }
 
+  ChunkedUploadDataStream* upload_chunked_data_stream() const {
+    return upload_chunked_data_stream_.get();
+  }
+
   SpdyTestUtil spdy_util_;
 
  private:
+  scoped_ptr<ChunkedUploadDataStream> upload_chunked_data_stream_;
   scoped_ptr<UploadDataStream> upload_data_stream_;
   bool google_get_request_initialized_;
   bool google_post_request_initialized_;
@@ -774,7 +779,7 @@
     // SpdyFramer::ConvertRequestPriorityToSpdyPriority to make
     // sure it's being done right.
     if (spdy_util_.spdy_version() < SPDY3) {
-      switch(p) {
+      switch (p) {
         case HIGHEST:
           EXPECT_EQ(0, spdy_prio);
           break;
@@ -1858,9 +1863,8 @@
 
   // These chunks get merged into a single frame when being sent.
   const int kFirstChunkSize = kUploadDataSize/2;
-  helper.request().upload_data_stream->AppendChunk(
-      kUploadData, kFirstChunkSize, false);
-  helper.request().upload_data_stream->AppendChunk(
+  upload_chunked_data_stream()->AppendData(kUploadData, kFirstChunkSize, false);
+  upload_chunked_data_stream()->AppendData(
       kUploadData + kFirstChunkSize, kUploadDataSize - kFirstChunkSize, true);
 
   helper.RunToCompletion(&data);
@@ -1898,19 +1902,16 @@
                                      DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
 
-  helper.request().upload_data_stream->AppendChunk(
-      kUploadData, kUploadDataSize, false);
+  upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, false);
 
   helper.RunPreTestSetup();
   helper.AddData(&data);
   ASSERT_TRUE(helper.StartDefaultTest());
 
   base::RunLoop().RunUntilIdle();
-  helper.request().upload_data_stream->AppendChunk(
-      kUploadData, kUploadDataSize, false);
+  upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, false);
   base::RunLoop().RunUntilIdle();
-  helper.request().upload_data_stream->AppendChunk(
-      kUploadData, kUploadDataSize, true);
+  upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, true);
 
   helper.FinishDefaultTest();
   helper.VerifyDataConsumed();
@@ -1972,7 +1973,7 @@
   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
   // Create an empty UploadDataStream.
   ScopedVector<UploadElementReader> element_readers;
-  UploadDataStream stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream stream(element_readers.Pass(), 0);
 
   // Setup the request
   HttpRequestInfo request;
@@ -2046,8 +2047,7 @@
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   // Finish sending the request body.
-  helper.request().upload_data_stream->AppendChunk(
-      kUploadData, kUploadDataSize, true);
+  upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, true);
   data.RunFor(2);
 
   std::string response_body;
@@ -4442,7 +4442,7 @@
   writes.push_back(CreateMockWrite(*initial_settings_frame));
   if (GetParam().protocol >= kProtoSPDY31) {
     writes.push_back(CreateMockWrite(*initial_window_update));
-  };
+  }
   writes.push_back(CreateMockWrite(*settings_frame));
   writes.push_back(CreateMockWrite(*req));
 
@@ -4608,7 +4608,7 @@
   };
 
   scoped_ptr<OrderedSocketData> data;
-  switch(GetParam().ssl_type) {
+  switch (GetParam().ssl_type) {
     case SPDYNOSSL:
       data.reset(new OrderedSocketData(reads_SPDYNOSSL,
                                        arraysize(reads_SPDYNOSSL),
@@ -4768,7 +4768,7 @@
   };
 
   scoped_ptr<OrderedSocketData> data_proxy;
-  switch(GetParam().ssl_type) {
+  switch (GetParam().ssl_type) {
     case SPDYNPN:
       data_proxy.reset(new OrderedSocketData(reads_SPDYNPN,
                                              arraysize(reads_SPDYNPN),
@@ -5888,7 +5888,7 @@
     element_readers.push_back(
         new UploadBytesElementReader(content->c_str(), content->size()));
   }
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   // Setup the request
   HttpRequestInfo request;
@@ -6053,7 +6053,7 @@
     element_readers.push_back(
         new UploadBytesElementReader(content->c_str(), content->size()));
   }
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   // Setup the request
   HttpRequestInfo request;
@@ -6169,7 +6169,7 @@
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size()));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -6286,7 +6286,7 @@
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size()));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
@@ -6413,7 +6413,7 @@
   upload_data_string.append(kUploadData, kUploadDataSize);
   element_readers.push_back(new UploadBytesElementReader(
       upload_data_string.c_str(), upload_data_string.size()));
-  UploadDataStream upload_data_stream(element_readers.Pass(), 0);
+  ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
diff --git a/net/spdy/spdy_protocol.h b/net/spdy/spdy_protocol.h
index 296ff0a..cb9bdfe 100644
--- a/net/spdy/spdy_protocol.h
+++ b/net/spdy/spdy_protocol.h
@@ -663,7 +663,7 @@
     data_ = data;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   // Used to store data that this SpdyDataIR should own.
@@ -698,7 +698,7 @@
     unidirectional_ = unidirectional;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId associated_to_stream_id_;
@@ -713,7 +713,7 @@
   explicit SpdySynReplyIR(SpdyStreamId stream_id)
       : SpdyFrameWithNameValueBlockIR(stream_id) {}
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdySynReplyIR);
@@ -739,7 +739,7 @@
     description_ = description;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyRstStreamStatus status_;
@@ -785,7 +785,7 @@
     is_ack_ = is_ack;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   ValueMap values_;
@@ -804,7 +804,7 @@
   bool is_ack() const { return is_ack_; }
   void set_is_ack(bool is_ack) { is_ack_ = is_ack; }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyPingId id_;
@@ -832,7 +832,7 @@
 
   const base::StringPiece& description() const;
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId last_good_stream_id_;
@@ -849,7 +849,7 @@
       has_priority_(false),
       priority_(0) {}
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
   bool has_priority() const { return has_priority_; }
   void set_has_priority(bool has_priority) { has_priority_ = has_priority; }
@@ -876,7 +876,7 @@
     delta_ = delta;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   int32 delta_;
@@ -890,7 +890,7 @@
   explicit SpdyBlockedIR(SpdyStreamId stream_id)
       : SpdyFrameWithStreamIdIR(stream_id) {}
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(SpdyBlockedIR);
@@ -905,7 +905,7 @@
   SpdyStreamId promised_stream_id() const { return promised_stream_id_; }
   void set_promised_stream_id(SpdyStreamId id) { promised_stream_id_ = id; }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId promised_stream_id_;
@@ -921,7 +921,7 @@
       : SpdyFrameWithNameValueBlockIR(stream_id),
         end_headers_(false) {}
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
   bool end_headers() const { return end_headers_; }
   void set_end_headers(bool end_headers) {end_headers_ = end_headers;}
@@ -955,7 +955,7 @@
     origin_ = origin;
   }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   uint32 max_age_;
@@ -980,7 +980,7 @@
   bool exclusive() const { return exclusive_; }
   void set_exclusive(bool exclusive) { exclusive_ = exclusive; }
 
-  virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE;
+  virtual void Visit(SpdyFrameVisitor* visitor) const override;
 
  private:
   SpdyStreamId parent_stream_id_;
diff --git a/net/spdy/spdy_proxy_client_socket.h b/net/spdy/spdy_proxy_client_socket.h
index 7a293a0..3b0736c 100644
--- a/net/spdy/spdy_proxy_client_socket.h
+++ b/net/spdy/spdy_proxy_client_socket.h
@@ -57,47 +57,47 @@
   virtual ~SpdyProxyClientSocket();
 
   // ProxyClientSocket methods:
-  virtual const HttpResponseInfo* GetConnectResponseInfo() const OVERRIDE;
-  virtual HttpStream* CreateConnectResponseStream() OVERRIDE;
+  virtual const HttpResponseInfo* GetConnectResponseInfo() const override;
+  virtual HttpStream* CreateConnectResponseStream() override;
   virtual const scoped_refptr<HttpAuthController>& GetAuthController() const
-      OVERRIDE;
-  virtual int RestartWithAuth(const CompletionCallback& callback) OVERRIDE;
-  virtual bool IsUsingSpdy() const OVERRIDE;
-  virtual NextProto GetProtocolNegotiated() const OVERRIDE;
+      override;
+  virtual int RestartWithAuth(const CompletionCallback& callback) override;
+  virtual bool IsUsingSpdy() const override;
+  virtual NextProto GetProtocolNegotiated() const override;
 
   // StreamSocket implementation.
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual bool IsConnected() const OVERRIDE;
-  virtual bool IsConnectedAndIdle() const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void SetSubresourceSpeculation() OVERRIDE;
-  virtual void SetOmniboxSpeculation() OVERRIDE;
-  virtual bool WasEverUsed() const OVERRIDE;
-  virtual bool UsingTCPFastOpen() const OVERRIDE;
-  virtual bool WasNpnNegotiated() const OVERRIDE;
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE;
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+  virtual int Connect(const CompletionCallback& callback) override;
+  virtual void Disconnect() override;
+  virtual bool IsConnected() const override;
+  virtual bool IsConnectedAndIdle() const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void SetSubresourceSpeculation() override;
+  virtual void SetOmniboxSpeculation() override;
+  virtual bool WasEverUsed() const override;
+  virtual bool UsingTCPFastOpen() const override;
+  virtual bool WasNpnNegotiated() const override;
+  virtual NextProto GetNegotiatedProtocol() const override;
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override;
 
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
 
   // SpdyStream::Delegate implementation.
-  virtual void OnRequestHeadersSent() OVERRIDE;
+  virtual void OnRequestHeadersSent() override;
   virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE;
-  virtual void OnDataSent() OVERRIDE;
-  virtual void OnClose(int status) OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
+  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override;
+  virtual void OnDataSent() override;
+  virtual void OnClose(int status) override;
 
  private:
   enum State {
diff --git a/net/spdy/spdy_session.cc b/net/spdy/spdy_session.cc
index d5f04ad..6afa427 100644
--- a/net/spdy/spdy_session.cc
+++ b/net/spdy/spdy_session.cc
@@ -16,6 +16,7 @@
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/stats_counters.h"
+#include "base/profiler/scoped_profile.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ -1336,6 +1337,11 @@
 }
 
 void SpdySession::PumpReadLoop(ReadState expected_read_state, int result) {
+  // TODO(vadimt): Remove ScopedProfile below once crbug.com/418183 is fixed.
+  tracked_objects::ScopedProfile tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "418183 DoReadCallback => SpdySession::PumpReadLoop"));
+
   CHECK(!in_io_loop_);
   if (availability_state_ == STATE_DRAINING) {
     return;
diff --git a/net/spdy/spdy_session.h b/net/spdy/spdy_session.h
index 519d07b..293ed2b 100644
--- a/net/spdy/spdy_session.h
+++ b/net/spdy/spdy_session.h
@@ -517,7 +517,7 @@
   base::WeakPtr<SpdySession> GetWeakPtr();
 
   // HigherLayeredPool implementation:
-  virtual bool CloseOneIdleConnection() OVERRIDE;
+  virtual bool CloseOneIdleConnection() override;
 
  private:
   friend class base::RefCounted<SpdySession>;
@@ -813,55 +813,55 @@
   void DeleteExpiredPushedStreams();
 
   // BufferedSpdyFramerVisitorInterface:
-  virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE;
+  virtual void OnError(SpdyFramer::SpdyError error_code) override;
   virtual void OnStreamError(SpdyStreamId stream_id,
-                             const std::string& description) OVERRIDE;
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE;
+                             const std::string& description) override;
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override;
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE;
+                           SpdyRstStreamStatus status) override;
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE;
+                        SpdyGoAwayStatus status) override;
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
-                                 bool fin) OVERRIDE;
+                                 bool fin) override;
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
-                                 bool fin) OVERRIDE;
-  virtual void OnSettings(bool clear_persisted) OVERRIDE;
+                                 bool fin) override;
+  virtual void OnSettings(bool clear_persisted) override;
   virtual void OnSetting(
-      SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE;
+      SpdySettingsIds id, uint8 flags, uint32 value) override;
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) OVERRIDE;
+                              uint32 delta_window_size) override;
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
-                             const SpdyHeaderBlock& headers) OVERRIDE;
+                             const SpdyHeaderBlock& headers) override;
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional,
-                           const SpdyHeaderBlock& headers) OVERRIDE;
+                           const SpdyHeaderBlock& headers) override;
   virtual void OnSynReply(
       SpdyStreamId stream_id,
       bool fin,
-      const SpdyHeaderBlock& headers) OVERRIDE;
+      const SpdyHeaderBlock& headers) override;
   virtual void OnHeaders(
       SpdyStreamId stream_id,
       bool fin,
-      const SpdyHeaderBlock& headers) OVERRIDE;
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE;
+      const SpdyHeaderBlock& headers) override;
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override;
 
   // SpdyFramerDebugVisitorInterface
   virtual void OnSendCompressedFrame(
       SpdyStreamId stream_id,
       SpdyFrameType type,
       size_t payload_len,
-      size_t frame_len) OVERRIDE;
+      size_t frame_len) override;
   virtual void OnReceiveCompressedFrame(
       SpdyStreamId stream_id,
       SpdyFrameType type,
-      size_t frame_len) OVERRIDE;
+      size_t frame_len) override;
 
   // Called when bytes are consumed from a SpdyBuffer for a DATA frame
   // that is to be written or is being written. Increases the send
diff --git a/net/spdy/spdy_session_pool.h b/net/spdy/spdy_session_pool.h
index 2fbb030..de2ddfa 100644
--- a/net/spdy/spdy_session_pool.h
+++ b/net/spdy/spdy_session_pool.h
@@ -133,19 +133,19 @@
   // We flush all idle sessions and release references to the active ones so
   // they won't get re-used.  The active ones will either complete successfully
   // or error out due to the IP address change.
-  virtual void OnIPAddressChanged() OVERRIDE;
+  virtual void OnIPAddressChanged() override;
 
   // SSLConfigService::Observer methods:
 
   // We perform the same flushing as described above when SSL settings change.
-  virtual void OnSSLConfigChanged() OVERRIDE;
+  virtual void OnSSLConfigChanged() override;
 
   // CertDatabase::Observer methods:
 
   // We perform the same flushing as described above when certificate database
   // is changed.
-  virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE;
-  virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE;
+  virtual void OnCertAdded(const X509Certificate* cert) override;
+  virtual void OnCACertChanged(const X509Certificate* cert) override;
 
  private:
   friend class SpdySessionPoolPeer;  // For testing.
diff --git a/net/spdy/spdy_session_pool_unittest.cc b/net/spdy/spdy_session_pool_unittest.cc
index 16a624b..ece5d34 100644
--- a/net/spdy/spdy_session_pool_unittest.cc
+++ b/net/spdy/spdy_session_pool_unittest.cc
@@ -64,18 +64,18 @@
 
   virtual ~SessionOpeningDelegate() {}
 
-  virtual void OnRequestHeadersSent() OVERRIDE {}
+  virtual void OnRequestHeadersSent() override {}
 
   virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE {
+      const SpdyHeaderBlock& response_headers) override {
     return RESPONSE_HEADERS_ARE_COMPLETE;
   }
 
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE {}
+  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override {}
 
-  virtual void OnDataSent() OVERRIDE {}
+  virtual void OnDataSent() override {}
 
-  virtual void OnClose(int status) OVERRIDE {
+  virtual void OnClose(int status) override {
     ignore_result(CreateFakeSpdySession(spdy_session_pool_, key_));
   }
 
diff --git a/net/spdy/spdy_session_test_util.h b/net/spdy/spdy_session_test_util.h
index 08a82ee..cc3f136 100644
--- a/net/spdy/spdy_session_test_util.h
+++ b/net/spdy/spdy_session_test_util.h
@@ -29,8 +29,8 @@
   virtual ~SpdySessionTestTaskObserver();
 
   // Implements MessageLoop::TaskObserver.
-  virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE;
-  virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE;
+  virtual void WillProcessTask(const base::PendingTask& pending_task) override;
+  virtual void DidProcessTask(const base::PendingTask& pending_task) override;
 
   // Returns the number of tasks posted by the given function and file.
   uint16 executed_count() const { return executed_count_; }
diff --git a/net/spdy/spdy_session_unittest.cc b/net/spdy/spdy_session_unittest.cc
index 938f6e5..914f6fe 100644
--- a/net/spdy/spdy_session_unittest.cc
+++ b/net/spdy/spdy_session_unittest.cc
@@ -121,7 +121,7 @@
         HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     g_time_delta = base::TimeDelta();
   }
 
@@ -885,7 +885,7 @@
   session->CheckPingStatus(before_ping_time);
 
   EXPECT_EQ(0, session->pings_in_flight());
-  EXPECT_GE(session->next_ping_id(), static_cast<uint32>(1));
+  EXPECT_GE(session->next_ping_id(), 1U);
   EXPECT_FALSE(session->check_ping_status_pending());
   EXPECT_GE(session->last_activity_time(), before_ping_time);
 
@@ -1302,7 +1302,7 @@
   // Send a PING frame.
   session->WritePingFrame(1, false);
   EXPECT_LT(0, session->pings_in_flight());
-  EXPECT_GE(session->next_ping_id(), static_cast<uint32>(1));
+  EXPECT_GE(session->next_ping_id(), 1U);
   EXPECT_TRUE(session->check_ping_status_pending());
 
   // Assert session is not closed.
@@ -2305,7 +2305,7 @@
 
   virtual ~SessionClosingDelegate() {}
 
-  virtual void OnClose(int status) OVERRIDE {
+  virtual void OnClose(int status) override {
     session_to_close_->CloseSessionOnError(ERR_SPDY_PROTOCOL_ERROR, "Error");
   }
 
@@ -3381,7 +3381,7 @@
 
   virtual ~StreamCreatingDelegate() {}
 
-  virtual void OnClose(int status) OVERRIDE {
+  virtual void OnClose(int status) override {
     GURL url(kDefaultURL);
     ignore_result(
         CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
@@ -3661,7 +3661,7 @@
   virtual ~DropReceivedDataDelegate() {}
 
   // Drop any received data.
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE {}
+  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override {}
 };
 
 // Send data back and forth but use a delegate that drops its received
@@ -4249,7 +4249,7 @@
     stream_to_close_ = stream_to_close;
   }
 
-  virtual void OnDataSent() OVERRIDE {
+  virtual void OnDataSent() override {
     test::StreamDelegateWithBody::OnDataSent();
     if (stream_to_close_.get()) {
       stream_to_close_->Close();
diff --git a/net/spdy/spdy_stream.cc b/net/spdy/spdy_stream.cc
index 3a0d988..6de0a39 100644
--- a/net/spdy/spdy_stream.cc
+++ b/net/spdy/spdy_stream.cc
@@ -63,7 +63,7 @@
 
   virtual ~SynStreamBufferProducer() {}
 
-  virtual scoped_ptr<SpdyBuffer> ProduceBuffer() OVERRIDE {
+  virtual scoped_ptr<SpdyBuffer> ProduceBuffer() override {
     if (!stream_.get()) {
       NOTREACHED();
       return scoped_ptr<SpdyBuffer>();
diff --git a/net/spdy/spdy_stream_test_util.h b/net/spdy/spdy_stream_test_util.h
index 0c0497e..7df12e8 100644
--- a/net/spdy/spdy_stream_test_util.h
+++ b/net/spdy/spdy_stream_test_util.h
@@ -26,12 +26,12 @@
   virtual ~ClosingDelegate();
 
   // SpdyStream::Delegate implementation.
-  virtual void OnRequestHeadersSent() OVERRIDE;
+  virtual void OnRequestHeadersSent() override;
   virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE;
-  virtual void OnDataSent() OVERRIDE;
-  virtual void OnClose(int status) OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
+  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override;
+  virtual void OnDataSent() override;
+  virtual void OnClose(int status) override;
 
   // Returns whether or not the stream is closed.
   bool StreamIsClosed() const { return !stream_.get(); }
@@ -47,12 +47,12 @@
   explicit StreamDelegateBase(const base::WeakPtr<SpdyStream>& stream);
   virtual ~StreamDelegateBase();
 
-  virtual void OnRequestHeadersSent() OVERRIDE;
+  virtual void OnRequestHeadersSent() override;
   virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE;
-  virtual void OnDataSent() OVERRIDE;
-  virtual void OnClose(int status) OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
+  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override;
+  virtual void OnDataSent() override;
+  virtual void OnClose(int status) override;
 
   // Waits for the stream to be closed and returns the status passed
   // to OnClose().
@@ -101,7 +101,7 @@
   virtual ~StreamDelegateSendImmediate();
 
   virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
 
  private:
   base::StringPiece data_;
@@ -114,7 +114,7 @@
                          base::StringPiece data);
   virtual ~StreamDelegateWithBody();
 
-  virtual void OnRequestHeadersSent() OVERRIDE;
+  virtual void OnRequestHeadersSent() override;
 
  private:
   scoped_refptr<StringIOBuffer> buf_;
@@ -127,7 +127,7 @@
   virtual ~StreamDelegateCloseOnHeaders();
 
   virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
 };
 
 } // namespace test
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 5de58d6..2e1aba5 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -214,44 +214,44 @@
     return priority_;
   }
 
-  virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {}
+  virtual void OnError(SpdyFramer::SpdyError error_code) override {}
   virtual void OnStreamError(SpdyStreamId stream_id,
-                             const std::string& description) OVERRIDE {}
+                             const std::string& description) override {}
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional,
-                           const SpdyHeaderBlock& headers) OVERRIDE {
+                           const SpdyHeaderBlock& headers) override {
     priority_ = priority;
   }
   virtual void OnSynReply(SpdyStreamId stream_id,
                           bool fin,
-                          const SpdyHeaderBlock& headers) OVERRIDE {}
+                          const SpdyHeaderBlock& headers) override {}
   virtual void OnHeaders(SpdyStreamId stream_id,
                          bool fin,
-                         const SpdyHeaderBlock& headers) OVERRIDE {}
+                         const SpdyHeaderBlock& headers) override {}
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
-                                 bool fin) OVERRIDE {}
+                                 bool fin) override {}
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
-                                 bool fin) OVERRIDE {}
-  virtual void OnSettings(bool clear_persisted) OVERRIDE {}
+                                 bool fin) override {}
+  virtual void OnSettings(bool clear_persisted) override {}
   virtual void OnSetting(
-      SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE {}
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {}
+      SpdySettingsIds id, uint8 flags, uint32 value) override {}
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {}
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE {}
+                           SpdyRstStreamStatus status) override {}
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE {}
+                        SpdyGoAwayStatus status) override {}
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) OVERRIDE {}
+                              uint32 delta_window_size) override {}
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
-                             const SpdyHeaderBlock& headers) OVERRIDE {}
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE {
+                             const SpdyHeaderBlock& headers) override {}
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override {
     return false;
   }
 
@@ -616,43 +616,43 @@
   virtual ~FakeSpdySessionClientSocket() {}
 
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE {
+                   const CompletionCallback& callback) override {
     return read_result_;
   }
 
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE {
+                    const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
   // Return kProtoUnknown to use the pool's default protocol.
-  virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
+  virtual NextProto GetNegotiatedProtocol() const override {
     return kProtoUnknown;
   }
 
   // The functions below are not expected to be called.
 
-  virtual int Connect(const CompletionCallback& callback) OVERRIDE {
+  virtual int Connect(const CompletionCallback& callback) override {
     ADD_FAILURE();
     return ERR_UNEXPECTED;
   }
 
-  virtual bool WasEverUsed() const OVERRIDE {
+  virtual bool WasEverUsed() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool UsingTCPFastOpen() const OVERRIDE {
+  virtual bool UsingTCPFastOpen() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool WasNpnNegotiated() const OVERRIDE {
+  virtual bool WasNpnNegotiated() const override {
     ADD_FAILURE();
     return false;
   }
 
-  virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
+  virtual bool GetSSLInfo(SSLInfo* ssl_info) override {
     ADD_FAILURE();
     return false;
   }
diff --git a/net/spdy/spdy_test_util_common.h b/net/spdy/spdy_test_util_common.h
index 108e278..897f670 100644
--- a/net/spdy/spdy_test_util_common.h
+++ b/net/spdy/spdy_test_util_common.h
@@ -159,9 +159,9 @@
   // crypto::ECSignatureCreator
   virtual bool Sign(const uint8* data,
                     int data_len,
-                    std::vector<uint8>* signature) OVERRIDE;
+                    std::vector<uint8>* signature) override;
   virtual bool DecodeSignature(const std::vector<uint8>& signature,
-                               std::vector<uint8>* out_raw_sig) OVERRIDE;
+                               std::vector<uint8>* out_raw_sig) override;
 
  private:
   crypto::ECPrivateKey* key_;
@@ -177,7 +177,7 @@
 
   // crypto::ECSignatureCreatorFactory
   virtual crypto::ECSignatureCreator* Create(
-      crypto::ECPrivateKey* key) OVERRIDE;
+      crypto::ECPrivateKey* key) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockECSignatureCreatorFactory);
diff --git a/net/spdy/spdy_websocket_stream.h b/net/spdy/spdy_websocket_stream.h
index 6998134..66a89e8 100644
--- a/net/spdy/spdy_websocket_stream.h
+++ b/net/spdy/spdy_websocket_stream.h
@@ -75,12 +75,12 @@
   void Close();
 
   // SpdyStream::Delegate
-  virtual void OnRequestHeadersSent() OVERRIDE;
+  virtual void OnRequestHeadersSent() override;
   virtual SpdyResponseHeadersStatus OnResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
-  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) OVERRIDE;
-  virtual void OnDataSent() OVERRIDE;
-  virtual void OnClose(int status) OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
+  virtual void OnDataReceived(scoped_ptr<SpdyBuffer> buffer) override;
+  virtual void OnDataSent() override;
+  virtual void OnClose(int status) override;
 
  private:
   friend class SpdyWebSocketStreamTest;
diff --git a/net/spdy/spdy_websocket_stream_unittest.cc b/net/spdy/spdy_websocket_stream_unittest.cc
index 5720675..5941bdf 100644
--- a/net/spdy/spdy_websocket_stream_unittest.cc
+++ b/net/spdy/spdy_websocket_stream_unittest.cc
@@ -74,7 +74,7 @@
     on_close_ = callback;
   }
 
-  virtual void OnCreatedSpdyStream(int result) OVERRIDE {
+  virtual void OnCreatedSpdyStream(int result) override {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_CREATED,
                                  SpdyHeaderBlock(),
@@ -83,7 +83,7 @@
     if (!on_created_.is_null())
       on_created_.Run(&events_.back());
   }
-  virtual void OnSentSpdyHeaders() OVERRIDE {
+  virtual void OnSentSpdyHeaders() override {
     events_.push_back(
         SpdyWebSocketStreamEvent(SpdyWebSocketStreamEvent::EVENT_SENT_HEADERS,
                                  SpdyHeaderBlock(),
@@ -93,7 +93,7 @@
       on_sent_data_.Run(&events_.back());
   }
   virtual void OnSpdyResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE {
+      const SpdyHeaderBlock& response_headers) override {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_RECEIVED_HEADER,
@@ -103,7 +103,7 @@
     if (!on_received_header_.is_null())
       on_received_header_.Run(&events_.back());
   }
-  virtual void OnSentSpdyData(size_t bytes_sent) OVERRIDE {
+  virtual void OnSentSpdyData(size_t bytes_sent) override {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_SENT_DATA,
@@ -113,7 +113,7 @@
     if (!on_sent_data_.is_null())
       on_sent_data_.Run(&events_.back());
   }
-  virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) OVERRIDE {
+  virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) override {
     std::string buffer_data;
     size_t buffer_len = 0;
     if (buffer) {
@@ -129,7 +129,7 @@
     if (!on_received_data_.is_null())
       on_received_data_.Run(&events_.back());
   }
-  virtual void OnCloseSpdyStream() OVERRIDE {
+  virtual void OnCloseSpdyStream() override {
     events_.push_back(
         SpdyWebSocketStreamEvent(
             SpdyWebSocketStreamEvent::EVENT_CLOSE,
diff --git a/net/spdy/spdy_write_queue_unittest.cc b/net/spdy/spdy_write_queue_unittest.cc
index 2ab415a..cb24d12 100644
--- a/net/spdy/spdy_write_queue_unittest.cc
+++ b/net/spdy/spdy_write_queue_unittest.cc
@@ -59,7 +59,7 @@
         base::Bind(RequeingBufferProducer::ConsumeCallback, queue));
   }
 
-  virtual scoped_ptr<SpdyBuffer> ProduceBuffer() OVERRIDE {
+  virtual scoped_ptr<SpdyBuffer> ProduceBuffer() override {
     return buffer_.Pass();
   }
 
diff --git a/net/ssl/channel_id_service_unittest.cc b/net/ssl/channel_id_service_unittest.cc
index e5f084d..52083e8 100644
--- a/net/ssl/channel_id_service_unittest.cc
+++ b/net/ssl/channel_id_service_unittest.cc
@@ -37,11 +37,11 @@
 
   virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
                                const base::Closure& task,
-                               base::TimeDelta delay) OVERRIDE {
+                               base::TimeDelta delay) override {
     return false;
   }
 
-  virtual bool RunsTasksOnCurrentThread() const OVERRIDE { return true; }
+  virtual bool RunsTasksOnCurrentThread() const override { return true; }
 
  protected:
   virtual ~FailingTaskRunner() {}
@@ -60,17 +60,17 @@
                            base::Time* expiration_time,
                            std::string* private_key_result,
                            std::string* cert_result,
-                           const GetChannelIDCallback& callback) OVERRIDE;
+                           const GetChannelIDCallback& callback) override;
 
   virtual void SetChannelID(const std::string& server_identifier,
                             base::Time creation_time,
                             base::Time expiration_time,
                             const std::string& private_key,
-                            const std::string& cert) OVERRIDE {
+                            const std::string& cert) override {
     channel_id_count_ = 1;
   }
 
-  virtual int GetChannelIDCount() OVERRIDE { return channel_id_count_; }
+  virtual int GetChannelIDCount() override { return channel_id_count_; }
 
   void CallGetChannelIDCallbackWithResult(int err,
                                           base::Time expiration_time,
diff --git a/net/ssl/client_cert_store_chromeos.h b/net/ssl/client_cert_store_chromeos.h
index 940888d..f14619a 100644
--- a/net/ssl/client_cert_store_chromeos.h
+++ b/net/ssl/client_cert_store_chromeos.h
@@ -27,14 +27,14 @@
   // ClientCertStoreNSS:
   virtual void GetClientCerts(const SSLCertRequestInfo& cert_request_info,
                               CertificateList* selected_certs,
-                              const base::Closure& callback) OVERRIDE;
+                              const base::Closure& callback) override;
 
  protected:
   // ClientCertStoreNSS:
   virtual void GetClientCertsImpl(CERTCertList* cert_list,
                                   const SSLCertRequestInfo& request,
                                   bool query_nssdb,
-                                  CertificateList* selected_certs) OVERRIDE;
+                                  CertificateList* selected_certs) override;
 
  private:
   void DidGetSystemAndPrivateSlot(const SSLCertRequestInfo* request,
diff --git a/net/ssl/client_cert_store_mac.h b/net/ssl/client_cert_store_mac.h
index b3f7ef3..5c697db 100644
--- a/net/ssl/client_cert_store_mac.h
+++ b/net/ssl/client_cert_store_mac.h
@@ -22,7 +22,7 @@
   // ClientCertStore:
   virtual void GetClientCerts(const SSLCertRequestInfo& cert_request_info,
                               CertificateList* selected_certs,
-                              const base::Closure& callback) OVERRIDE;
+                              const base::Closure& callback) override;
 
  private:
   friend class ClientCertStoreMacTest;
diff --git a/net/ssl/client_cert_store_nss.h b/net/ssl/client_cert_store_nss.h
index 4e2e1c4..38895aa 100644
--- a/net/ssl/client_cert_store_nss.h
+++ b/net/ssl/client_cert_store_nss.h
@@ -32,7 +32,7 @@
   // ClientCertStore:
   virtual void GetClientCerts(const SSLCertRequestInfo& cert_request_info,
                               CertificateList* selected_certs,
-                              const base::Closure& callback) OVERRIDE;
+                              const base::Closure& callback) override;
 
  protected:
   // Examines the certificates in |cert_list| to find all certificates that
diff --git a/net/ssl/client_cert_store_win.h b/net/ssl/client_cert_store_win.h
index 785603d..567c267 100644
--- a/net/ssl/client_cert_store_win.h
+++ b/net/ssl/client_cert_store_win.h
@@ -22,7 +22,7 @@
   // ClientCertStore:
   virtual void GetClientCerts(const SSLCertRequestInfo& cert_request_info,
                               CertificateList* selected_certs,
-                              const base::Closure& callback) OVERRIDE;
+                              const base::Closure& callback) override;
 
  private:
   friend class ClientCertStoreWinTestDelegate;
diff --git a/net/ssl/default_channel_id_store.cc b/net/ssl/default_channel_id_store.cc
index 1dec6c1..4f43fbc 100644
--- a/net/ssl/default_channel_id_store.cc
+++ b/net/ssl/default_channel_id_store.cc
@@ -42,7 +42,7 @@
   GetChannelIDTask(const std::string& server_identifier,
                    const GetChannelIDCallback& callback);
   virtual ~GetChannelIDTask();
-  virtual void Run(DefaultChannelIDStore* store) OVERRIDE;
+  virtual void Run(DefaultChannelIDStore* store) override;
 
  private:
   std::string server_identifier_;
@@ -84,7 +84,7 @@
                    const std::string& private_key,
                    const std::string& cert);
   virtual ~SetChannelIDTask();
-  virtual void Run(DefaultChannelIDStore* store) OVERRIDE;
+  virtual void Run(DefaultChannelIDStore* store) override;
 
  private:
   std::string server_identifier_;
@@ -124,7 +124,7 @@
   DeleteChannelIDTask(const std::string& server_identifier,
                       const base::Closure& callback);
   virtual ~DeleteChannelIDTask();
-  virtual void Run(DefaultChannelIDStore* store) OVERRIDE;
+  virtual void Run(DefaultChannelIDStore* store) override;
 
  private:
   std::string server_identifier_;
@@ -159,7 +159,7 @@
                               base::Time delete_end,
                               const base::Closure& callback);
   virtual ~DeleteAllCreatedBetweenTask();
-  virtual void Run(DefaultChannelIDStore* store) OVERRIDE;
+  virtual void Run(DefaultChannelIDStore* store) override;
 
  private:
   base::Time delete_begin_;
@@ -195,7 +195,7 @@
  public:
   explicit GetAllChannelIDsTask(const GetChannelIDListCallback& callback);
   virtual ~GetAllChannelIDsTask();
-  virtual void Run(DefaultChannelIDStore* store) OVERRIDE;
+  virtual void Run(DefaultChannelIDStore* store) override;
 
  private:
   std::string server_identifier_;
diff --git a/net/ssl/default_channel_id_store.h b/net/ssl/default_channel_id_store.h
index 9c307e8..3882c1f 100644
--- a/net/ssl/default_channel_id_store.h
+++ b/net/ssl/default_channel_id_store.h
@@ -49,25 +49,25 @@
       base::Time* expiration_time,
       std::string* private_key_result,
       std::string* cert_result,
-      const GetChannelIDCallback& callback) OVERRIDE;
+      const GetChannelIDCallback& callback) override;
   virtual void SetChannelID(
       const std::string& server_identifier,
       base::Time creation_time,
       base::Time expiration_time,
       const std::string& private_key,
-      const std::string& cert) OVERRIDE;
+      const std::string& cert) override;
   virtual void DeleteChannelID(
       const std::string& server_identifier,
-      const base::Closure& callback) OVERRIDE;
+      const base::Closure& callback) override;
   virtual void DeleteAllCreatedBetween(
       base::Time delete_begin,
       base::Time delete_end,
-      const base::Closure& callback) OVERRIDE;
-  virtual void DeleteAll(const base::Closure& callback) OVERRIDE;
+      const base::Closure& callback) override;
+  virtual void DeleteAll(const base::Closure& callback) override;
   virtual void GetAllChannelIDs(
-      const GetChannelIDListCallback& callback) OVERRIDE;
-  virtual int GetChannelIDCount() OVERRIDE;
-  virtual void SetForceKeepSessionState() OVERRIDE;
+      const GetChannelIDListCallback& callback) override;
+  virtual int GetChannelIDCount() override;
+  virtual void SetForceKeepSessionState() override;
 
  private:
   class Task;
diff --git a/net/ssl/default_channel_id_store_unittest.cc b/net/ssl/default_channel_id_store_unittest.cc
index b1fe873..9429753 100644
--- a/net/ssl/default_channel_id_store_unittest.cc
+++ b/net/ssl/default_channel_id_store_unittest.cc
@@ -69,12 +69,12 @@
   MockPersistentStore();
 
   // DefaultChannelIDStore::PersistentStore implementation.
-  virtual void Load(const LoadedCallback& loaded_callback) OVERRIDE;
+  virtual void Load(const LoadedCallback& loaded_callback) override;
   virtual void AddChannelID(
-      const DefaultChannelIDStore::ChannelID& channel_id) OVERRIDE;
+      const DefaultChannelIDStore::ChannelID& channel_id) override;
   virtual void DeleteChannelID(
-      const DefaultChannelIDStore::ChannelID& channel_id) OVERRIDE;
-  virtual void SetForceKeepSessionState() OVERRIDE;
+      const DefaultChannelIDStore::ChannelID& channel_id) override;
+  virtual void SetForceKeepSessionState() override;
 
  protected:
   virtual ~MockPersistentStore();
diff --git a/net/ssl/openssl_client_key_store.cc b/net/ssl/openssl_client_key_store.cc
index b0b5eb3..de65cd9 100644
--- a/net/ssl/openssl_client_key_store.cc
+++ b/net/ssl/openssl_client_key_store.cc
@@ -6,6 +6,7 @@
 
 #include <openssl/evp.h>
 #include <openssl/x509.h>
+#include <algorithm>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
@@ -50,15 +51,14 @@
       private_key(EVP_PKEY_dup(other.private_key.get())) {
 }
 
-void OpenSSLClientKeyStore::KeyPair::operator=(const KeyPair& other) {
-  // Use a temporary ScopedEVP_PKEY because scoped_ptr does not allow resetting
-  // to the current value, even though it's safe here.
-  crypto::ScopedEVP_PKEY public_key_tmp(EVP_PKEY_dup(other.public_key.get()));
-  crypto::ScopedEVP_PKEY private_key_tmp(EVP_PKEY_dup(other.private_key.get()));
-  public_key.reset();
-  public_key = public_key_tmp.Pass();
-  private_key.reset();
-  private_key = private_key_tmp.Pass();
+void OpenSSLClientKeyStore::KeyPair::operator=(KeyPair other) {
+  swap(other);
+}
+
+void OpenSSLClientKeyStore::KeyPair::swap(KeyPair& other) {
+  using std::swap;
+  swap(public_key, other.public_key);
+  swap(private_key, other.private_key);
 }
 
 int OpenSSLClientKeyStore::FindKeyPairIndex(EVP_PKEY* public_key) {
diff --git a/net/ssl/openssl_client_key_store.h b/net/ssl/openssl_client_key_store.h
index 0cbb23a..6c06148 100644
--- a/net/ssl/openssl_client_key_store.h
+++ b/net/ssl/openssl_client_key_store.h
@@ -73,7 +73,9 @@
    public:
     explicit KeyPair(EVP_PKEY* pub_key, EVP_PKEY* priv_key);
     KeyPair(const KeyPair& other);
-    void operator=(const KeyPair& other);
+    // Intentionally pass by value, in order to use the copy-and-swap idiom.
+    void operator=(KeyPair other);
+    void swap(KeyPair& other);
     ~KeyPair();
 
     crypto::ScopedEVP_PKEY public_key;
diff --git a/net/ssl/ssl_client_auth_cache.h b/net/ssl/ssl_client_auth_cache.h
index 93ad8c0..4ee47ed 100644
--- a/net/ssl/ssl_client_auth_cache.h
+++ b/net/ssl/ssl_client_auth_cache.h
@@ -48,7 +48,7 @@
   void Remove(const HostPortPair& server);
 
   // CertDatabase::Observer methods:
-  virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE;
+  virtual void OnCertAdded(const X509Certificate* cert) override;
 
  private:
   typedef HostPortPair AuthCacheKey;
diff --git a/net/ssl/ssl_config.cc b/net/ssl/ssl_config.cc
index 269934b..b823f6b 100644
--- a/net/ssl/ssl_config.cc
+++ b/net/ssl/ssl_config.cc
@@ -10,6 +10,8 @@
 
 const uint16 kDefaultSSLVersionMax = SSL_PROTOCOL_VERSION_TLS1_2;
 
+const uint16 kDefaultSSLVersionFallbackMin = SSL_PROTOCOL_VERSION_TLS1;
+
 SSLConfig::CertAndStatus::CertAndStatus() : cert_status(0) {}
 
 SSLConfig::CertAndStatus::~CertAndStatus() {}
@@ -19,6 +21,7 @@
       rev_checking_required_local_anchors(false),
       version_min(kDefaultSSLVersionMin),
       version_max(kDefaultSSLVersionMax),
+      version_fallback_min(kDefaultSSLVersionFallbackMin),
       channel_id_enabled(true),
       false_start_enabled(true),
       signed_cert_timestamps_enabled(true),
diff --git a/net/ssl/ssl_config.h b/net/ssl/ssl_config.h
index 2731214..1deaf6e 100644
--- a/net/ssl/ssl_config.h
+++ b/net/ssl/ssl_config.h
@@ -32,6 +32,9 @@
 // Default maximum protocol version.
 NET_EXPORT extern const uint16 kDefaultSSLVersionMax;
 
+// Default minimum protocol version that it's acceptable to fallback to.
+NET_EXPORT extern const uint16 kDefaultSSLVersionFallbackMin;
+
 // A collection of SSL-related configuration settings.
 struct NET_EXPORT SSLConfig {
   // Default to revocation checking.
@@ -73,6 +76,12 @@
   uint16 version_min;
   uint16 version_max;
 
+  // version_fallback_min contains the minimum version that is acceptable to
+  // fallback to. Versions before this may be tried to see whether they would
+  // have succeeded and thus to give a better message to the user, but the
+  // resulting connection won't be used in these cases.
+  uint16 version_fallback_min;
+
   // Presorted list of cipher suites which should be explicitly prevented from
   // being used in addition to those disabled by the net built-in policy.
   //
diff --git a/net/ssl/ssl_config_service_defaults.h b/net/ssl/ssl_config_service_defaults.h
index 85123da..ff58029 100644
--- a/net/ssl/ssl_config_service_defaults.h
+++ b/net/ssl/ssl_config_service_defaults.h
@@ -18,7 +18,7 @@
   SSLConfigServiceDefaults();
 
   // Store default SSL config settings in |config|.
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE;
+  virtual void GetSSLConfig(SSLConfig* config) override;
 
  private:
   virtual ~SSLConfigServiceDefaults();
diff --git a/net/ssl/ssl_config_service_unittest.cc b/net/ssl/ssl_config_service_unittest.cc
index e8a4c33..0d9659c 100644
--- a/net/ssl/ssl_config_service_unittest.cc
+++ b/net/ssl/ssl_config_service_unittest.cc
@@ -19,7 +19,7 @@
   explicit MockSSLConfigService(const SSLConfig& config) : config_(config) {}
 
   // SSLConfigService implementation
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {
+  virtual void GetSSLConfig(SSLConfig* config) override {
     *config = config_;
   }
 
diff --git a/net/test/embedded_test_server/embedded_test_server.cc b/net/test/embedded_test_server/embedded_test_server.cc
index 3d609cc..b266c55 100644
--- a/net/test/embedded_test_server/embedded_test_server.cc
+++ b/net/test/embedded_test_server/embedded_test_server.cc
@@ -32,7 +32,7 @@
       : headers_(headers), contents_(contents) {
   }
 
-  virtual std::string ToResponseString() const OVERRIDE {
+  virtual std::string ToResponseString() const override {
     return headers_ + "\r\n" + contents_;
   }
 
diff --git a/net/test/embedded_test_server/embedded_test_server.h b/net/test/embedded_test_server/embedded_test_server.h
index 82303e5..fc9f554 100644
--- a/net/test/embedded_test_server/embedded_test_server.h
+++ b/net/test/embedded_test_server/embedded_test_server.h
@@ -167,11 +167,11 @@
 
   // StreamListenSocket::Delegate overrides:
   virtual void DidAccept(StreamListenSocket* server,
-                         scoped_ptr<StreamListenSocket> connection) OVERRIDE;
+                         scoped_ptr<StreamListenSocket> connection) override;
   virtual void DidRead(StreamListenSocket* connection,
                        const char* data,
-                       int length) OVERRIDE;
-  virtual void DidClose(StreamListenSocket* connection) OVERRIDE;
+                       int length) override;
+  virtual void DidClose(StreamListenSocket* connection) override;
 
   HttpConnection* FindConnection(StreamListenSocket* socket);
 
diff --git a/net/test/embedded_test_server/embedded_test_server_unittest.cc b/net/test/embedded_test_server/embedded_test_server_unittest.cc
index 9823947..9da982c 100644
--- a/net/test/embedded_test_server/embedded_test_server_unittest.cc
+++ b/net/test/embedded_test_server/embedded_test_server_unittest.cc
@@ -49,7 +49,7 @@
         io_thread_("io_thread") {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     base::Thread::Options thread_options;
     thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
     ASSERT_TRUE(io_thread_.StartWithOptions(thread_options));
@@ -61,12 +61,12 @@
     ASSERT_TRUE(server_->InitializeAndWaitUntilReady());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     ASSERT_TRUE(server_->ShutdownAndWaitUntilComplete());
   }
 
   // URLFetcherDelegate override.
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE {
+  virtual void OnURLFetchComplete(const URLFetcher* source) override {
     ++num_responses_received_;
     if (num_responses_received_ == num_responses_expected_)
       base::MessageLoop::current()->Quit();
@@ -260,7 +260,7 @@
         message_loop_present_on_shutdown_(message_loop_present_on_shutdown) {}
 
   // base::PlatformThread::Delegate:
-  virtual void ThreadMain() OVERRIDE {
+  virtual void ThreadMain() override {
     scoped_refptr<base::SingleThreadTaskRunner> io_thread_runner;
     base::Thread io_thread("io_thread");
     base::Thread::Options thread_options;
@@ -298,7 +298,7 @@
   }
 
   // URLFetcherDelegate override.
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE {
+  virtual void OnURLFetchComplete(const URLFetcher* source) override {
     base::MessageLoop::current()->Quit();
   }
 
diff --git a/net/test/embedded_test_server/http_response.h b/net/test/embedded_test_server/http_response.h
index 422a525..2172354 100644
--- a/net/test/embedded_test_server/http_response.h
+++ b/net/test/embedded_test_server/http_response.h
@@ -54,7 +54,7 @@
   }
 
   // Generates and returns a http response string.
-  virtual std::string ToResponseString() const OVERRIDE;
+  virtual std::string ToResponseString() const override;
 
  private:
   HttpStatusCode code_;
diff --git a/net/test/net_test_suite.cc b/net/test/net_test_suite.cc
index 175cec2..ed8a103 100644
--- a/net/test/net_test_suite.cc
+++ b/net/test/net_test_suite.cc
@@ -15,7 +15,7 @@
 #endif
 
 class StaticReset : public ::testing::EmptyTestEventListener {
-  virtual void OnTestStart(const ::testing::TestInfo& test_info) OVERRIDE {
+  virtual void OnTestStart(const ::testing::TestInfo& test_info) override {
     net::HttpStreamFactory::ResetStaticSettingsToInit();
   }
 };
diff --git a/net/test/net_test_suite.h b/net/test/net_test_suite.h
index c8479d7..1a400d4 100644
--- a/net/test/net_test_suite.h
+++ b/net/test/net_test_suite.h
@@ -23,9 +23,9 @@
   NetTestSuite(int argc, char** argv);
   virtual ~NetTestSuite();
 
-  virtual void Initialize() OVERRIDE;
+  virtual void Initialize() override;
 
-  virtual void Shutdown() OVERRIDE;
+  virtual void Shutdown() override;
 
  protected:
   // This constructor is only accessible to specialized net test
diff --git a/net/test/spawned_test_server/local_test_server_posix.cc b/net/test/spawned_test_server/local_test_server_posix.cc
index fdcfdab..64c9b44 100644
--- a/net/test/spawned_test_server/local_test_server_posix.cc
+++ b/net/test/spawned_test_server/local_test_server_posix.cc
@@ -34,7 +34,7 @@
       : path_string_(path_string),
         port_string_(port_string) {}
 
-  virtual bool Includes(const base::ProcessEntry& entry) const OVERRIDE {
+  virtual bool Includes(const base::ProcessEntry& entry) const override {
     if (entry.parent_pid() != 1)
       return false;
     bool found_path_string = false;
diff --git a/net/test/spawned_test_server/spawner_communicator.cc b/net/test/spawned_test_server/spawner_communicator.cc
index 9aadb87..53484ea 100644
--- a/net/test/spawned_test_server/spawner_communicator.cc
+++ b/net/test/spawned_test_server/spawner_communicator.cc
@@ -12,10 +12,10 @@
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/net_util.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
-#include "net/base/upload_data_stream.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_test_util.h"
 #include "url/gurl.h"
@@ -188,10 +188,10 @@
     cur_request_->set_method("POST");
     scoped_ptr<UploadElementReader> reader(
         UploadOwnedBytesElementReader::CreateWithString(post_data));
-    cur_request_->set_upload(make_scoped_ptr(
-        UploadDataStream::CreateWithReader(reader.Pass(), 0)));
-    net::HttpRequestHeaders headers;
-    headers.SetHeader(net::HttpRequestHeaders::kContentType,
+    cur_request_->set_upload(
+        ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0));
+    HttpRequestHeaders headers;
+    headers.SetHeader(HttpRequestHeaders::kContentType,
                       "application/json");
     cur_request_->SetExtraRequestHeaders(headers);
   }
diff --git a/net/test/spawned_test_server/spawner_communicator.h b/net/test/spawned_test_server/spawner_communicator.h
index b657ac3..549ad91 100644
--- a/net/test/spawned_test_server/spawner_communicator.h
+++ b/net/test/spawned_test_server/spawner_communicator.h
@@ -100,8 +100,8 @@
                                              std::string* data_received);
 
   // URLRequest::Delegate methods. Called on the IO thread.
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
-  virtual void OnReadCompleted(URLRequest* request, int num_bytes) OVERRIDE;
+  virtual void OnResponseStarted(URLRequest* request) override;
+  virtual void OnReadCompleted(URLRequest* request, int num_bytes) override;
 
   // Reads Result from the response. Called on the IO thread.
   void ReadResult(URLRequest* request);
diff --git a/net/test/url_request/url_request_failed_job.h b/net/test/url_request/url_request_failed_job.h
index 6d3cf2d..ea35116 100644
--- a/net/test/url_request/url_request_failed_job.h
+++ b/net/test/url_request/url_request_failed_job.h
@@ -22,7 +22,7 @@
                       NetworkDelegate* network_delegate,
                       int net_error);
 
-  virtual void Start() OVERRIDE;
+  virtual void Start() override;
 
   // Adds the testing URLs to the URLRequestFilter.
   static void AddUrlHandler();
diff --git a/net/test/url_request/url_request_mock_http_job.cc b/net/test/url_request/url_request_mock_http_job.cc
index 42af81f..c611f36 100644
--- a/net/test/url_request/url_request_mock_http_job.cc
+++ b/net/test/url_request/url_request_mock_http_job.cc
@@ -42,7 +42,7 @@
   // net::URLRequestJobFactory::ProtocolHandler implementation
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     return new URLRequestMockHTTPJob(
         request,
         network_delegate,
diff --git a/net/test/url_request/url_request_mock_http_job.h b/net/test/url_request/url_request_mock_http_job.h
index cb93412..eb68a2d 100644
--- a/net/test/url_request/url_request_mock_http_job.h
+++ b/net/test/url_request/url_request_mock_http_job.h
@@ -34,13 +34,13 @@
                         const base::FilePath& file_path,
                         const scoped_refptr<base::TaskRunner>& task_runner);
 
-  virtual void Start() OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
-  virtual bool GetCharset(std::string* charset) OVERRIDE;
-  virtual void GetResponseInfo(HttpResponseInfo* info) OVERRIDE;
+  virtual void Start() override;
+  virtual bool GetMimeType(std::string* mime_type) const override;
+  virtual int GetResponseCode() const override;
+  virtual bool GetCharset(std::string* charset) override;
+  virtual void GetResponseInfo(HttpResponseInfo* info) override;
   virtual bool IsRedirectResponse(GURL* location,
-                                  int* http_status_code) OVERRIDE;
+                                  int* http_status_code) override;
 
   // Adds the testing URLs to the URLRequestFilter.
   static void AddUrlHandler(
diff --git a/net/tools/balsa/balsa_frame.h b/net/tools/balsa/balsa_frame.h
index 6178d79..73c3dd9 100644
--- a/net/tools/balsa/balsa_frame.h
+++ b/net/tools/balsa/balsa_frame.h
@@ -201,11 +201,11 @@
 
  private:
   class DoNothingBalsaVisitor : public BalsaVisitorInterface {
-    virtual void ProcessBodyInput(const char *input, size_t size) OVERRIDE {}
-    virtual void ProcessBodyData(const char *input, size_t size) OVERRIDE {}
-    virtual void ProcessHeaderInput(const char *input, size_t size) OVERRIDE {}
-    virtual void ProcessTrailerInput(const char *input, size_t size) OVERRIDE {}
-    virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE {}
+    virtual void ProcessBodyInput(const char *input, size_t size) override {}
+    virtual void ProcessBodyData(const char *input, size_t size) override {}
+    virtual void ProcessHeaderInput(const char *input, size_t size) override {}
+    virtual void ProcessTrailerInput(const char *input, size_t size) override {}
+    virtual void ProcessHeaders(const BalsaHeaders& headers) override {}
     virtual void ProcessRequestFirstLine(const char* line_input,
                                          size_t line_length,
                                          const char* method_input,
@@ -213,7 +213,7 @@
                                          const char* request_uri_input,
                                          size_t request_uri_length,
                                          const char* version_input,
-                                         size_t version_length) OVERRIDE {}
+                                         size_t version_length) override {}
     virtual void ProcessResponseFirstLine(const char *line_input,
                                           size_t line_length,
                                           const char *version_input,
@@ -221,16 +221,16 @@
                                           const char *status_input,
                                           size_t status_length,
                                           const char *reason_input,
-                                          size_t reason_length) OVERRIDE {}
-    virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE {}
+                                          size_t reason_length) override {}
+    virtual void ProcessChunkLength(size_t chunk_length) override {}
     virtual void ProcessChunkExtensions(const char *input,
-                                        size_t size) OVERRIDE {}
-    virtual void HeaderDone() OVERRIDE {}
-    virtual void MessageDone() OVERRIDE {}
-    virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE {}
-    virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {}
-    virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE {}
-    virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE {}
+                                        size_t size) override {}
+    virtual void HeaderDone() override {}
+    virtual void MessageDone() override {}
+    virtual void HandleHeaderError(BalsaFrame* framer) override {}
+    virtual void HandleHeaderWarning(BalsaFrame* framer) override {}
+    virtual void HandleChunkingError(BalsaFrame* framer) override {}
+    virtual void HandleBodyError(BalsaFrame* framer) override {}
   };
 
   bool last_char_was_slash_r_;
diff --git a/net/tools/balsa/balsa_frame_test.cc b/net/tools/balsa/balsa_frame_test.cc
index 2582721..334f5ef 100644
--- a/net/tools/balsa/balsa_frame_test.cc
+++ b/net/tools/balsa/balsa_frame_test.cc
@@ -58,7 +58,7 @@
 
 class BalsaFrameTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     frame_.reset(new BalsaFrame);
     frame_headers_.reset(new BalsaHeaders);
     visitor_.reset(new Visitor);
diff --git a/net/tools/balsa/balsa_headers_test.cc b/net/tools/balsa/balsa_headers_test.cc
index da2ad19..b1479c6 100644
--- a/net/tools/balsa/balsa_headers_test.cc
+++ b/net/tools/balsa/balsa_headers_test.cc
@@ -19,7 +19,7 @@
 
 class BalsaBufferTest : public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     buffer_.reset(new BalsaBuffer);
     anotherBuffer_.reset(new BalsaBuffer);
   }
@@ -33,7 +33,7 @@
 
 class BalsaHeadersTest: public ::testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     headers_.reset(new BalsaHeaders);
   }
 
diff --git a/net/tools/balsa/noop_balsa_visitor.h b/net/tools/balsa/noop_balsa_visitor.h
index c0136f1..c47b0b3 100644
--- a/net/tools/balsa/noop_balsa_visitor.h
+++ b/net/tools/balsa/noop_balsa_visitor.h
@@ -19,11 +19,11 @@
   NoOpBalsaVisitor() { }
   virtual ~NoOpBalsaVisitor() { }
 
-  virtual void ProcessBodyInput(const char* input, size_t size) OVERRIDE { }
-  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE { }
-  virtual void ProcessHeaderInput(const char* input, size_t size) OVERRIDE { }
-  virtual void ProcessTrailerInput(const char* input, size_t size) OVERRIDE { }
-  virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE { }
+  virtual void ProcessBodyInput(const char* input, size_t size) override { }
+  virtual void ProcessBodyData(const char* input, size_t size) override { }
+  virtual void ProcessHeaderInput(const char* input, size_t size) override { }
+  virtual void ProcessTrailerInput(const char* input, size_t size) override { }
+  virtual void ProcessHeaders(const BalsaHeaders& headers) override { }
 
   virtual void ProcessRequestFirstLine(const char* line_input,
                                        size_t line_length,
@@ -32,7 +32,7 @@
                                        const char* request_uri_input,
                                        size_t request_uri_length,
                                        const char* version_input,
-                                       size_t version_length) OVERRIDE { }
+                                       size_t version_length) override { }
   virtual void ProcessResponseFirstLine(const char* line_input,
                                         size_t line_length,
                                         const char* version_input,
@@ -40,16 +40,16 @@
                                         const char* status_input,
                                         size_t status_length,
                                         const char* reason_input,
-                                        size_t reason_length) OVERRIDE { }
-  virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE { }
-  virtual void ProcessChunkExtensions(const char* input, size_t size) OVERRIDE {
+                                        size_t reason_length) override { }
+  virtual void ProcessChunkLength(size_t chunk_length) override { }
+  virtual void ProcessChunkExtensions(const char* input, size_t size) override {
   }
-  virtual void HeaderDone() OVERRIDE { }
-  virtual void MessageDone() OVERRIDE { }
-  virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE { }
-  virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE { }
-  virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE { }
-  virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE { }
+  virtual void HeaderDone() override { }
+  virtual void MessageDone() override { }
+  virtual void HandleHeaderError(BalsaFrame* framer) override { }
+  virtual void HandleHeaderWarning(BalsaFrame* framer) override { }
+  virtual void HandleChunkingError(BalsaFrame* framer) override { }
+  virtual void HandleBodyError(BalsaFrame* framer) override { }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NoOpBalsaVisitor);
diff --git a/net/tools/balsa/simple_buffer.h b/net/tools/balsa/simple_buffer.h
index a550617..d58894e 100644
--- a/net/tools/balsa/simple_buffer.h
+++ b/net/tools/balsa/simple_buffer.h
@@ -32,32 +32,32 @@
   // The following functions all override pure virtual functions
   // in BufferInterface. See buffer_interface.h for a description
   // of what they do.
-  virtual int ReadableBytes() const OVERRIDE;
-  virtual int BufferSize() const OVERRIDE;
-  virtual int BytesFree() const OVERRIDE;
+  virtual int ReadableBytes() const override;
+  virtual int BufferSize() const override;
+  virtual int BytesFree() const override;
 
-  virtual bool Empty() const OVERRIDE;
-  virtual bool Full() const OVERRIDE;
+  virtual bool Empty() const override;
+  virtual bool Full() const override;
 
-  virtual int Write(const char* bytes, int size) OVERRIDE;
+  virtual int Write(const char* bytes, int size) override;
 
-  virtual void GetWritablePtr(char **ptr, int* size) const OVERRIDE;
+  virtual void GetWritablePtr(char **ptr, int* size) const override;
 
-  virtual void GetReadablePtr(char **ptr, int* size) const OVERRIDE;
+  virtual void GetReadablePtr(char **ptr, int* size) const override;
 
-  virtual int Read(char* bytes, int size) OVERRIDE;
+  virtual int Read(char* bytes, int size) override;
 
-  virtual void Clear() OVERRIDE;
+  virtual void Clear() override;
 
   // This can be an expensive operation: costing a new/delete, and copying of
   // all existing data. Even if the existing buffer does not need to be
   // resized, unread data may still need to be non-destructively copied to
   // consolidate fragmented free space.
-  virtual bool Reserve(int size) OVERRIDE;
+  virtual bool Reserve(int size) override;
 
-  virtual void AdvanceReadablePtr(int amount_to_advance) OVERRIDE;
+  virtual void AdvanceReadablePtr(int amount_to_advance) override;
 
-  virtual void AdvanceWritablePtr(int amount_to_advance) OVERRIDE;
+  virtual void AdvanceWritablePtr(int amount_to_advance) override;
 
   void Swap(SimpleBuffer* other) {
     char* tmp = storage_;
diff --git a/net/tools/dump_cache/cache_dumper.h b/net/tools/dump_cache/cache_dumper.h
index 9c5837c..46c3eec 100644
--- a/net/tools/dump_cache/cache_dumper.h
+++ b/net/tools/dump_cache/cache_dumper.h
@@ -48,12 +48,12 @@
   explicit CacheDumper(disk_cache::Backend* cache);
 
   virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
-                          const net::CompletionCallback& callback) OVERRIDE;
+                          const net::CompletionCallback& callback) override;
   virtual int WriteEntry(disk_cache::Entry* entry, int stream, int offset,
                          net::IOBuffer* buf, int buf_len,
-                         const net::CompletionCallback& callback) OVERRIDE;
+                         const net::CompletionCallback& callback) override;
   virtual void CloseEntry(disk_cache::Entry* entry, base::Time last_used,
-                          base::Time last_modified) OVERRIDE;
+                          base::Time last_modified) override;
 
  private:
   disk_cache::Backend* cache_;
@@ -65,12 +65,12 @@
   explicit DiskDumper(const base::FilePath& path);
 
   virtual int CreateEntry(const std::string& key, disk_cache::Entry** entry,
-                          const net::CompletionCallback& callback) OVERRIDE;
+                          const net::CompletionCallback& callback) override;
   virtual int WriteEntry(disk_cache::Entry* entry, int stream, int offset,
                          net::IOBuffer* buf, int buf_len,
-                         const net::CompletionCallback& callback) OVERRIDE;
+                         const net::CompletionCallback& callback) override;
   virtual void CloseEntry(disk_cache::Entry* entry, base::Time last_used,
-                          base::Time last_modified) OVERRIDE;
+                          base::Time last_modified) override;
 
  private:
   base::FilePath path_;
diff --git a/net/tools/epoll_server/epoll_server.cc b/net/tools/epoll_server/epoll_server.cc
index a382dba..7ccae1d 100644
--- a/net/tools/epoll_server/epoll_server.cc
+++ b/net/tools/epoll_server/epoll_server.cc
@@ -60,7 +60,7 @@
 // Clears the pipe and returns.  Used for waking the epoll server up.
 class ReadPipeCallback : public EpollCallbackInterface {
  public:
-  virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE {
+  virtual void OnEvent(int fd, EpollEvent* event) override {
     DCHECK(event->in_events == EPOLLIN);
     int data;
     int data_read = 1;
@@ -69,10 +69,10 @@
       data_read = read(fd, &data, sizeof(data));
     }
   }
-  virtual void OnShutdown(EpollServer *eps, int fd) OVERRIDE {}
-  virtual void OnRegistration(EpollServer*, int, int) OVERRIDE {}
-  virtual void OnModification(int, int) OVERRIDE {}       // COV_NF_LINE
-  virtual void OnUnregistration(int, bool) OVERRIDE {}    // COV_NF_LINE
+  virtual void OnShutdown(EpollServer *eps, int fd) override {}
+  virtual void OnRegistration(EpollServer*, int, int) override {}
+  virtual void OnModification(int, int) override {}       // COV_NF_LINE
+  virtual void OnUnregistration(int, bool) override {}    // COV_NF_LINE
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/net/tools/epoll_server/epoll_server.h b/net/tools/epoll_server/epoll_server.h
index 8822450..e8f1396 100644
--- a/net/tools/epoll_server/epoll_server.h
+++ b/net/tools/epoll_server/epoll_server.h
@@ -1023,17 +1023,17 @@
 
   // Marks the alarm as unregistered and returns 0.  The return value may be
   // safely ignored by subclasses.
-  virtual int64 OnAlarm() OVERRIDE;
+  virtual int64 OnAlarm() override;
 
   // Marks the alarm as registered, and stores the token.
   virtual void OnRegistration(const EpollServer::AlarmRegToken& token,
-                              EpollServer* eps) OVERRIDE;
+                              EpollServer* eps) override;
 
   // Marks the alarm as unregistered.
-  virtual void OnUnregistration() OVERRIDE;
+  virtual void OnUnregistration() override;
 
   // Marks the alarm as unregistered.
-  virtual void OnShutdown(EpollServer* eps) OVERRIDE;
+  virtual void OnShutdown(EpollServer* eps) override;
 
   // If the alarm was registered, unregister it.
   void UnregisterIfRegistered();
diff --git a/net/tools/flip_server/acceptor_thread.h b/net/tools/flip_server/acceptor_thread.h
index bcaa43e..ecb4316 100644
--- a/net/tools/flip_server/acceptor_thread.h
+++ b/net/tools/flip_server/acceptor_thread.h
@@ -52,14 +52,14 @@
   // EpollCallbackInteface interface
   virtual void OnRegistration(EpollServer* eps,
                               int fd,
-                              int event_mask) OVERRIDE {}
-  virtual void OnModification(int fd, int event_mask) OVERRIDE {}
-  virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
-  virtual void OnUnregistration(int fd, bool replaced) OVERRIDE {}
-  virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {}
+                              int event_mask) override {}
+  virtual void OnModification(int fd, int event_mask) override {}
+  virtual void OnEvent(int fd, EpollEvent* event) override;
+  virtual void OnUnregistration(int fd, bool replaced) override {}
+  virtual void OnShutdown(EpollServer* eps, int fd) override {}
 
   // SMConnectionPool interface
-  virtual void SMConnectionDone(SMConnection* sc) OVERRIDE;
+  virtual void SMConnectionDone(SMConnection* sc) override;
 
   // TODO(mbelshe): figure out if we can move these to private functions.
   SMConnection* NewConnection();
@@ -75,7 +75,7 @@
   // idle longer than the configured timeout.
   void HandleConnectionIdleTimeout();
 
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  private:
   EpollServer epoll_server_;
diff --git a/net/tools/flip_server/http_interface.h b/net/tools/flip_server/http_interface.h
index 30b7979..08a595e 100644
--- a/net/tools/flip_server/http_interface.h
+++ b/net/tools/flip_server/http_interface.h
@@ -32,11 +32,11 @@
 
  private:
   // BalsaVisitorInterface:
-  virtual void ProcessBodyInput(const char* input, size_t size) OVERRIDE {}
-  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE;
-  virtual void ProcessHeaderInput(const char* input, size_t size) OVERRIDE {}
-  virtual void ProcessTrailerInput(const char* input, size_t size) OVERRIDE {}
-  virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE;
+  virtual void ProcessBodyInput(const char* input, size_t size) override {}
+  virtual void ProcessBodyData(const char* input, size_t size) override;
+  virtual void ProcessHeaderInput(const char* input, size_t size) override {}
+  virtual void ProcessTrailerInput(const char* input, size_t size) override {}
+  virtual void ProcessHeaders(const BalsaHeaders& headers) override;
   virtual void ProcessRequestFirstLine(const char* line_input,
                                        size_t line_length,
                                        const char* method_input,
@@ -44,7 +44,7 @@
                                        const char* request_uri_input,
                                        size_t request_uri_length,
                                        const char* version_input,
-                                       size_t version_length) OVERRIDE {}
+                                       size_t version_length) override {}
   virtual void ProcessResponseFirstLine(const char* line_input,
                                         size_t line_length,
                                         const char* version_input,
@@ -52,28 +52,28 @@
                                         const char* status_input,
                                         size_t status_length,
                                         const char* reason_input,
-                                        size_t reason_length) OVERRIDE {}
-  virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE {}
-  virtual void ProcessChunkExtensions(const char* input, size_t size) OVERRIDE {
+                                        size_t reason_length) override {}
+  virtual void ProcessChunkLength(size_t chunk_length) override {}
+  virtual void ProcessChunkExtensions(const char* input, size_t size) override {
   }
-  virtual void HeaderDone() OVERRIDE {}
-  virtual void MessageDone() OVERRIDE;
-  virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE;
-  virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {}
-  virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE;
-  virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE;
+  virtual void HeaderDone() override {}
+  virtual void MessageDone() override;
+  virtual void HandleHeaderError(BalsaFrame* framer) override;
+  virtual void HandleHeaderWarning(BalsaFrame* framer) override {}
+  virtual void HandleChunkingError(BalsaFrame* framer) override;
+  virtual void HandleBodyError(BalsaFrame* framer) override;
 
   void HandleError();
 
  public:
   void AddToOutputOrder(const MemCacheIter& mci);
   BalsaFrame* spdy_framer() { return http_framer_; }
-  virtual void set_is_request() OVERRIDE {}
+  virtual void set_is_request() override {}
   const OutputOrdering& output_ordering() const { return output_ordering_; }
 
   // SMInterface:
   virtual void InitSMInterface(SMInterface* sm_spdy_interface,
-                               int32 server_idx) OVERRIDE;
+                               int32 server_idx) override;
   virtual void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                                 SMInterface* sm_interface,
                                 EpollServer* epoll_server,
@@ -81,33 +81,33 @@
                                 std::string server_ip,
                                 std::string server_port,
                                 std::string remote_ip,
-                                bool use_ssl) OVERRIDE;
-  virtual size_t ProcessReadInput(const char* data, size_t len) OVERRIDE;
-  virtual size_t ProcessWriteInput(const char* data, size_t len) OVERRIDE;
-  virtual bool MessageFullyRead() const OVERRIDE;
-  virtual void SetStreamID(uint32 stream_id) OVERRIDE;
-  virtual bool Error() const OVERRIDE;
-  virtual const char* ErrorAsString() const OVERRIDE;
-  virtual void Reset() OVERRIDE;
-  virtual void ResetForNewInterface(int32 server_idx) OVERRIDE {}
-  virtual void ResetForNewConnection() OVERRIDE;
-  virtual void Cleanup() OVERRIDE;
-  virtual int PostAcceptHook() OVERRIDE;
+                                bool use_ssl) override;
+  virtual size_t ProcessReadInput(const char* data, size_t len) override;
+  virtual size_t ProcessWriteInput(const char* data, size_t len) override;
+  virtual bool MessageFullyRead() const override;
+  virtual void SetStreamID(uint32 stream_id) override;
+  virtual bool Error() const override;
+  virtual const char* ErrorAsString() const override;
+  virtual void Reset() override;
+  virtual void ResetForNewInterface(int32 server_idx) override {}
+  virtual void ResetForNewConnection() override;
+  virtual void Cleanup() override;
+  virtual int PostAcceptHook() override;
 
   virtual void NewStream(uint32 stream_id,
                          uint32 priority,
-                         const std::string& filename) OVERRIDE;
-  virtual void SendEOF(uint32 stream_id) OVERRIDE;
-  virtual void SendErrorNotFound(uint32 stream_id) OVERRIDE;
+                         const std::string& filename) override;
+  virtual void SendEOF(uint32 stream_id) override;
+  virtual void SendErrorNotFound(uint32 stream_id) override;
   virtual size_t SendSynStream(uint32 stream_id,
-                               const BalsaHeaders& headers) OVERRIDE;
+                               const BalsaHeaders& headers) override;
   virtual size_t SendSynReply(uint32 stream_id,
-                              const BalsaHeaders& headers) OVERRIDE;
+                              const BalsaHeaders& headers) override;
   virtual void SendDataFrame(uint32 stream_id,
                              const char* data,
                              int64 len,
                              uint32 flags,
-                             bool compress) OVERRIDE;
+                             bool compress) override;
 
  private:
   void SendEOFImpl(uint32 stream_id);
@@ -121,7 +121,7 @@
                          uint32 flags,
                          bool compress);
   void EnqueueDataFrame(DataFrame* df);
-  virtual void GetOutput() OVERRIDE;
+  virtual void GetOutput() override;
 
  private:
   BalsaFrame* http_framer_;
diff --git a/net/tools/flip_server/http_interface_test.cc b/net/tools/flip_server/http_interface_test.cc
index 969607b..9e72279 100644
--- a/net/tools/flip_server/http_interface_test.cc
+++ b/net/tools/flip_server/http_interface_test.cc
@@ -86,7 +86,7 @@
                                 acceptor_.get()));
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (acceptor_->listen_fd_ >= 0) {
       epoll_server_->UnregisterFD(acceptor_->listen_fd_);
       close(acceptor_->listen_fd_);
diff --git a/net/tools/flip_server/mem_cache.h b/net/tools/flip_server/mem_cache.h
index 76ffc95..63befee 100644
--- a/net/tools/flip_server/mem_cache.h
+++ b/net/tools/flip_server/mem_cache.h
@@ -21,11 +21,11 @@
   void HandleError() { error_ = true; }
 
   // BalsaVisitorInterface:
-  virtual void ProcessBodyInput(const char* input, size_t size) OVERRIDE {}
-  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE;
-  virtual void ProcessHeaderInput(const char* input, size_t size) OVERRIDE {}
-  virtual void ProcessTrailerInput(const char* input, size_t size) OVERRIDE {}
-  virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE {
+  virtual void ProcessBodyInput(const char* input, size_t size) override {}
+  virtual void ProcessBodyData(const char* input, size_t size) override;
+  virtual void ProcessHeaderInput(const char* input, size_t size) override {}
+  virtual void ProcessTrailerInput(const char* input, size_t size) override {}
+  virtual void ProcessHeaders(const BalsaHeaders& headers) override {
     // nothing to do here-- we're assuming that the BalsaFrame has
     // been handed our headers.
   }
@@ -36,7 +36,7 @@
                                        const char* request_uri_input,
                                        size_t request_uri_length,
                                        const char* version_input,
-                                       size_t version_length) OVERRIDE {}
+                                       size_t version_length) override {}
   virtual void ProcessResponseFirstLine(const char* line_input,
                                         size_t line_length,
                                         const char* version_input,
@@ -44,16 +44,16 @@
                                         const char* status_input,
                                         size_t status_length,
                                         const char* reason_input,
-                                        size_t reason_length) OVERRIDE {}
-  virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE {}
-  virtual void ProcessChunkExtensions(const char* input, size_t size) OVERRIDE {
+                                        size_t reason_length) override {}
+  virtual void ProcessChunkLength(size_t chunk_length) override {}
+  virtual void ProcessChunkExtensions(const char* input, size_t size) override {
   }
-  virtual void HeaderDone() OVERRIDE {}
-  virtual void MessageDone() OVERRIDE {}
-  virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE;
-  virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE;
-  virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE;
-  virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE;
+  virtual void HeaderDone() override {}
+  virtual void MessageDone() override {}
+  virtual void HandleHeaderError(BalsaFrame* framer) override;
+  virtual void HandleHeaderWarning(BalsaFrame* framer) override;
+  virtual void HandleChunkingError(BalsaFrame* framer) override;
+  virtual void HandleBodyError(BalsaFrame* framer) override;
 
   BalsaHeaders headers;
   std::string body;
diff --git a/net/tools/flip_server/mem_cache_test.cc b/net/tools/flip_server/mem_cache_test.cc
index 5e45bb5..bb01907 100644
--- a/net/tools/flip_server/mem_cache_test.cc
+++ b/net/tools/flip_server/mem_cache_test.cc
@@ -16,7 +16,7 @@
   virtual ~MemoryCacheWithFakeReadToString() {}
 
   virtual void ReadToString(const char* filename,
-                            std::string* output) OVERRIDE {
+                            std::string* output) override {
     *output = data_map_[filename];
   }
 
diff --git a/net/tools/flip_server/output_ordering.h b/net/tools/flip_server/output_ordering.h
index 596f382..488d2e9 100644
--- a/net/tools/flip_server/output_ordering.h
+++ b/net/tools/flip_server/output_ordering.h
@@ -56,11 +56,11 @@
     virtual ~BeginOutputtingAlarm();
 
     // EpollAlarmCallbackInterface:
-    virtual int64 OnAlarm() OVERRIDE;
+    virtual int64 OnAlarm() override;
     virtual void OnRegistration(const EpollServer::AlarmRegToken& tok,
-                                EpollServer* eps) OVERRIDE;
-    virtual void OnUnregistration() OVERRIDE;
-    virtual void OnShutdown(EpollServer* eps) OVERRIDE;
+                                EpollServer* eps) override;
+    virtual void OnUnregistration() override;
+    virtual void OnShutdown(EpollServer* eps) override;
 
    private:
     OutputOrdering* output_ordering_;
diff --git a/net/tools/flip_server/ring_buffer.h b/net/tools/flip_server/ring_buffer.h
index b129ee8..bb3b39f 100644
--- a/net/tools/flip_server/ring_buffer.h
+++ b/net/tools/flip_server/ring_buffer.h
@@ -38,32 +38,32 @@
   // The following functions all override pure virtual functions
   // in BufferInterface. See buffer_interface.h for a description
   // of what they do if the function isn't documented here.
-  virtual int ReadableBytes() const OVERRIDE;
-  virtual int BufferSize() const OVERRIDE;
-  virtual int BytesFree() const OVERRIDE;
+  virtual int ReadableBytes() const override;
+  virtual int BufferSize() const override;
+  virtual int BytesFree() const override;
 
-  virtual bool Empty() const OVERRIDE;
-  virtual bool Full() const OVERRIDE;
+  virtual bool Empty() const override;
+  virtual bool Full() const override;
 
   // returns the number of characters written.
   // appends up-to-'size' bytes to the ringbuffer.
-  virtual int Write(const char* bytes, int size) OVERRIDE;
+  virtual int Write(const char* bytes, int size) override;
 
   // Stores a pointer into the ring buffer in *ptr,  and stores the number of
   // characters which are allowed to be written in *size.
   // If there are no writable bytes available, then *size will contain 0.
-  virtual void GetWritablePtr(char** ptr, int* size) const OVERRIDE;
+  virtual void GetWritablePtr(char** ptr, int* size) const override;
 
   // Stores a pointer into the ring buffer in *ptr,  and stores the number of
   // characters which are allowed to be read in *size.
   // If there are no readable bytes available, then *size will contain 0.
-  virtual void GetReadablePtr(char** ptr, int* size) const OVERRIDE;
+  virtual void GetReadablePtr(char** ptr, int* size) const override;
 
   // Returns the number of bytes read into 'bytes'.
-  virtual int Read(char* bytes, int size) OVERRIDE;
+  virtual int Read(char* bytes, int size) override;
 
   // Removes all data from the ring buffer.
-  virtual void Clear() OVERRIDE;
+  virtual void Clear() override;
 
   // Reserves contiguous writable empty space in the buffer of size bytes.
   // Since the point of this class is to have a fixed size buffer, be careful
@@ -76,15 +76,15 @@
   // to consolidate fragmented free space. If the size requested is less than
   // or equal to BytesFree(), it is guaranteed that the buffer size will not
   // change.
-  virtual bool Reserve(int size) OVERRIDE;
+  virtual bool Reserve(int size) override;
 
   // Removes the oldest 'amount_to_advance' characters.
   // If amount_to_consume > ReadableBytes(), this performs a Clear() instead.
-  virtual void AdvanceReadablePtr(int amount_to_advance) OVERRIDE;
+  virtual void AdvanceReadablePtr(int amount_to_advance) override;
 
   // Moves the internal pointers around such that the  amount of data specified
   // here is expected to already be resident (as if it was Written).
-  virtual void AdvanceWritablePtr(int amount_to_advance) OVERRIDE;
+  virtual void AdvanceWritablePtr(int amount_to_advance) override;
 
  protected:
   int read_idx() const { return read_idx_; }
diff --git a/net/tools/flip_server/sm_connection.h b/net/tools/flip_server/sm_connection.h
index 2fe3228..5c5a5fd 100644
--- a/net/tools/flip_server/sm_connection.h
+++ b/net/tools/flip_server/sm_connection.h
@@ -57,10 +57,10 @@
   std::string server_ip_;
   std::string server_port_;
 
-  virtual EpollServer* epoll_server() OVERRIDE;
+  virtual EpollServer* epoll_server() override;
   OutputList* output_list() { return &output_list_; }
   MemoryCache* memory_cache() { return memory_cache_; }
-  virtual void ReadyToSend() OVERRIDE;
+  virtual void ReadyToSend() override;
   void EnqueueDataFrame(DataFrame* df);
 
   int fd() const { return fd_; }
@@ -84,14 +84,14 @@
   // EpollCallbackInterface interface.
   virtual void OnRegistration(EpollServer* eps,
                               int fd,
-                              int event_mask) OVERRIDE;
-  virtual void OnModification(int fd, int event_mask) OVERRIDE {}
-  virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
-  virtual void OnUnregistration(int fd, bool replaced) OVERRIDE;
-  virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE;
+                              int event_mask) override;
+  virtual void OnModification(int fd, int event_mask) override {}
+  virtual void OnEvent(int fd, EpollEvent* event) override;
+  virtual void OnUnregistration(int fd, bool replaced) override;
+  virtual void OnShutdown(EpollServer* eps, int fd) override;
 
   // NotifierInterface interface.
-  virtual void Notify() OVERRIDE {}
+  virtual void Notify() override {}
 
   void Cleanup(const char* cleanup);
 
diff --git a/net/tools/flip_server/spdy_interface.h b/net/tools/flip_server/spdy_interface.h
index 2174274..2d2437a 100644
--- a/net/tools/flip_server/spdy_interface.h
+++ b/net/tools/flip_server/spdy_interface.h
@@ -35,7 +35,7 @@
   virtual ~SpdySM();
 
   virtual void InitSMInterface(SMInterface* sm_http_interface,
-                               int32 server_idx) OVERRIDE {}
+                               int32 server_idx) override {}
 
   virtual void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                                 SMInterface* sm_interface,
@@ -44,13 +44,13 @@
                                 std::string server_ip,
                                 std::string server_port,
                                 std::string remote_ip,
-                                bool use_ssl) OVERRIDE;
+                                bool use_ssl) override;
 
   // Create new SPDY framer after reusing SpdySM and negotiating new version
   void CreateFramer(SpdyMajorVersion spdy_version);
 
  private:
-  virtual void set_is_request() OVERRIDE {}
+  virtual void set_is_request() override {}
   SMInterface* NewConnectionInterface();
   // virtual for tests
   virtual SMInterface* FindOrMakeNewSMConnectionInterface(
@@ -63,31 +63,31 @@
                           bool* is_https_scheme);
 
   // BufferedSpdyFramerVisitorInterface:
-  virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {}
+  virtual void OnError(SpdyFramer::SpdyError error_code) override {}
   virtual void OnStreamError(SpdyStreamId stream_id,
-                             const std::string& description) OVERRIDE {}
+                             const std::string& description) override {}
   // Called after all the header data for SYN_STREAM control frame is received.
   virtual void OnSynStream(SpdyStreamId stream_id,
                            SpdyStreamId associated_stream_id,
                            SpdyPriority priority,
                            bool fin,
                            bool unidirectional,
-                           const SpdyHeaderBlock& headers) OVERRIDE;
+                           const SpdyHeaderBlock& headers) override;
 
   // Called after all the header data for SYN_REPLY control frame is received.
   virtual void OnSynReply(SpdyStreamId stream_id,
                           bool fin,
-                          const SpdyHeaderBlock& headers) OVERRIDE;
+                          const SpdyHeaderBlock& headers) override;
 
   // Called after all the header data for HEADERS control frame is received.
   virtual void OnHeaders(SpdyStreamId stream_id,
                          bool fin,
-                         const SpdyHeaderBlock& headers) OVERRIDE;
+                         const SpdyHeaderBlock& headers) override;
 
   // Called when data frame header is received.
   virtual void OnDataFrameHeader(SpdyStreamId stream_id,
                                  size_t length,
-                                 bool fin) OVERRIDE {}
+                                 bool fin) override {}
 
   // Called when data is received.
   // |stream_id| The stream receiving data.
@@ -98,73 +98,73 @@
   virtual void OnStreamFrameData(SpdyStreamId stream_id,
                                  const char* data,
                                  size_t len,
-                                 bool fin) OVERRIDE;
+                                 bool fin) override;
 
   // Called when a SETTINGS frame is received.
   // |clear_persisted| True if the respective flag is set on the SETTINGS frame.
-  virtual void OnSettings(bool clear_persisted) OVERRIDE {}
+  virtual void OnSettings(bool clear_persisted) override {}
 
   // Called when an individual setting within a SETTINGS frame has been parsed
   // and validated.
   virtual void OnSetting(SpdySettingsIds id,
                          uint8 flags,
-                         uint32 value) OVERRIDE {}
+                         uint32 value) override {}
 
   // Called when a PING frame has been parsed.
-  virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {}
+  virtual void OnPing(SpdyPingId unique_id, bool is_ack) override {}
 
   // Called when a RST_STREAM frame has been parsed.
   virtual void OnRstStream(SpdyStreamId stream_id,
-                           SpdyRstStreamStatus status) OVERRIDE;
+                           SpdyRstStreamStatus status) override;
 
   // Called when a GOAWAY frame has been parsed.
   virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                        SpdyGoAwayStatus status) OVERRIDE {}
+                        SpdyGoAwayStatus status) override {}
 
   // Called when a WINDOW_UPDATE frame has been parsed.
   virtual void OnWindowUpdate(SpdyStreamId stream_id,
-                              uint32 delta_window_size) OVERRIDE {}
+                              uint32 delta_window_size) override {}
 
   // Called when a PUSH_PROMISE frame has been parsed.
   virtual void OnPushPromise(SpdyStreamId stream_id,
                              SpdyStreamId promised_stream_id,
-                             const SpdyHeaderBlock& headers) OVERRIDE {}
+                             const SpdyHeaderBlock& headers) override {}
 
-  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE;
+  virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override;
 
  public:
-  virtual size_t ProcessReadInput(const char* data, size_t len) OVERRIDE;
-  virtual size_t ProcessWriteInput(const char* data, size_t len) OVERRIDE;
-  virtual bool MessageFullyRead() const OVERRIDE;
-  virtual void SetStreamID(uint32 stream_id) OVERRIDE {}
-  virtual bool Error() const OVERRIDE;
-  virtual const char* ErrorAsString() const OVERRIDE;
-  virtual void Reset() OVERRIDE {}
-  virtual void ResetForNewInterface(int32 server_idx) OVERRIDE;
-  virtual void ResetForNewConnection() OVERRIDE;
+  virtual size_t ProcessReadInput(const char* data, size_t len) override;
+  virtual size_t ProcessWriteInput(const char* data, size_t len) override;
+  virtual bool MessageFullyRead() const override;
+  virtual void SetStreamID(uint32 stream_id) override {}
+  virtual bool Error() const override;
+  virtual const char* ErrorAsString() const override;
+  virtual void Reset() override {}
+  virtual void ResetForNewInterface(int32 server_idx) override;
+  virtual void ResetForNewConnection() override;
   // SMInterface's Cleanup is currently only called by SMConnection after a
   // protocol message as been fully read. Spdy's SMInterface does not need
   // to do any cleanup at this time.
   // TODO(klindsay) This method is probably not being used properly and
   // some logic review and method renaming is probably in order.
-  virtual void Cleanup() OVERRIDE {}
+  virtual void Cleanup() override {}
   // Send a settings frame
-  virtual int PostAcceptHook() OVERRIDE;
+  virtual int PostAcceptHook() override;
   virtual void NewStream(uint32 stream_id,
                          uint32 priority,
-                         const std::string& filename) OVERRIDE;
+                         const std::string& filename) override;
   void AddToOutputOrder(const MemCacheIter& mci);
-  virtual void SendEOF(uint32 stream_id) OVERRIDE;
-  virtual void SendErrorNotFound(uint32 stream_id) OVERRIDE;
+  virtual void SendEOF(uint32 stream_id) override;
+  virtual void SendErrorNotFound(uint32 stream_id) override;
   virtual size_t SendSynStream(uint32 stream_id,
-                               const BalsaHeaders& headers) OVERRIDE;
+                               const BalsaHeaders& headers) override;
   virtual size_t SendSynReply(uint32 stream_id,
-                              const BalsaHeaders& headers) OVERRIDE;
+                              const BalsaHeaders& headers) override;
   virtual void SendDataFrame(uint32 stream_id,
                              const char* data,
                              int64 len,
                              uint32 flags,
-                             bool compress) OVERRIDE;
+                             bool compress) override;
   BufferedSpdyFramer* spdy_framer() { return buffered_spdy_framer_.get(); }
 
   const OutputOrdering& output_ordering() const {
@@ -193,7 +193,7 @@
                          SpdyDataFlags flags,
                          bool compress);
   void EnqueueDataFrame(DataFrame* df);
-  virtual void GetOutput() OVERRIDE;
+  virtual void GetOutput() override;
 
  private:
   scoped_ptr<BufferedSpdyFramer> buffered_spdy_framer_;
diff --git a/net/tools/flip_server/streamer_interface.h b/net/tools/flip_server/streamer_interface.h
index 0114491..ca04f1e 100644
--- a/net/tools/flip_server/streamer_interface.h
+++ b/net/tools/flip_server/streamer_interface.h
@@ -31,7 +31,7 @@
   void AddToOutputOrder(const MemCacheIter& mci) {}
 
   virtual void InitSMInterface(SMInterface* sm_other_interface,
-                               int32 server_idx) OVERRIDE;
+                               int32 server_idx) override;
   virtual void InitSMConnection(SMConnectionPoolInterface* connection_pool,
                                 SMInterface* sm_interface,
                                 EpollServer* epoll_server,
@@ -39,35 +39,35 @@
                                 std::string server_ip,
                                 std::string server_port,
                                 std::string remote_ip,
-                                bool use_ssl) OVERRIDE;
+                                bool use_ssl) override;
 
-  virtual size_t ProcessReadInput(const char* data, size_t len) OVERRIDE;
-  virtual size_t ProcessWriteInput(const char* data, size_t len) OVERRIDE;
-  virtual bool MessageFullyRead() const OVERRIDE;
-  virtual void SetStreamID(uint32 stream_id) OVERRIDE {}
-  virtual bool Error() const OVERRIDE;
-  virtual const char* ErrorAsString() const OVERRIDE;
-  virtual void Reset() OVERRIDE;
-  virtual void ResetForNewInterface(int32 server_idx) OVERRIDE {}
-  virtual void ResetForNewConnection() OVERRIDE;
-  virtual void Cleanup() OVERRIDE;
-  virtual int PostAcceptHook() OVERRIDE;
+  virtual size_t ProcessReadInput(const char* data, size_t len) override;
+  virtual size_t ProcessWriteInput(const char* data, size_t len) override;
+  virtual bool MessageFullyRead() const override;
+  virtual void SetStreamID(uint32 stream_id) override {}
+  virtual bool Error() const override;
+  virtual const char* ErrorAsString() const override;
+  virtual void Reset() override;
+  virtual void ResetForNewInterface(int32 server_idx) override {}
+  virtual void ResetForNewConnection() override;
+  virtual void Cleanup() override;
+  virtual int PostAcceptHook() override;
   virtual void NewStream(uint32 stream_id,
                          uint32 priority,
-                         const std::string& filename) OVERRIDE {}
-  virtual void SendEOF(uint32 stream_id) OVERRIDE {}
-  virtual void SendErrorNotFound(uint32 stream_id) OVERRIDE {}
+                         const std::string& filename) override {}
+  virtual void SendEOF(uint32 stream_id) override {}
+  virtual void SendErrorNotFound(uint32 stream_id) override {}
   virtual void SendOKResponse(uint32 stream_id, std::string output) {}
   virtual size_t SendSynStream(uint32 stream_id,
-                               const BalsaHeaders& headers) OVERRIDE;
+                               const BalsaHeaders& headers) override;
   virtual size_t SendSynReply(uint32 stream_id,
-                              const BalsaHeaders& headers) OVERRIDE;
+                              const BalsaHeaders& headers) override;
   virtual void SendDataFrame(uint32 stream_id,
                              const char* data,
                              int64 len,
                              uint32 flags,
-                             bool compress) OVERRIDE {}
-  virtual void set_is_request() OVERRIDE;
+                             bool compress) override {}
+  virtual void set_is_request() override;
   static std::string forward_ip_header() { return forward_ip_header_; }
   static void set_forward_ip_header(std::string value) {
     forward_ip_header_ = value;
@@ -88,14 +88,14 @@
                          int64 len,
                          uint32 flags,
                          bool compress) {}
-  virtual void GetOutput() OVERRIDE {}
+  virtual void GetOutput() override {}
 
-  virtual void ProcessBodyInput(const char* input, size_t size) OVERRIDE;
-  virtual void MessageDone() OVERRIDE;
-  virtual void ProcessHeaders(const BalsaHeaders& headers) OVERRIDE;
-  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {}
-  virtual void ProcessHeaderInput(const char* input, size_t size) OVERRIDE {}
-  virtual void ProcessTrailerInput(const char* input, size_t size) OVERRIDE {}
+  virtual void ProcessBodyInput(const char* input, size_t size) override;
+  virtual void MessageDone() override;
+  virtual void ProcessHeaders(const BalsaHeaders& headers) override;
+  virtual void ProcessBodyData(const char* input, size_t size) override {}
+  virtual void ProcessHeaderInput(const char* input, size_t size) override {}
+  virtual void ProcessTrailerInput(const char* input, size_t size) override {}
   virtual void ProcessRequestFirstLine(const char* line_input,
                                        size_t line_length,
                                        const char* method_input,
@@ -103,7 +103,7 @@
                                        const char* request_uri_input,
                                        size_t request_uri_length,
                                        const char* version_input,
-                                       size_t version_length) OVERRIDE {}
+                                       size_t version_length) override {}
   virtual void ProcessResponseFirstLine(const char* line_input,
                                         size_t line_length,
                                         const char* version_input,
@@ -111,15 +111,15 @@
                                         const char* status_input,
                                         size_t status_length,
                                         const char* reason_input,
-                                        size_t reason_length) OVERRIDE {}
-  virtual void ProcessChunkLength(size_t chunk_length) OVERRIDE {}
-  virtual void ProcessChunkExtensions(const char* input, size_t size) OVERRIDE {
+                                        size_t reason_length) override {}
+  virtual void ProcessChunkLength(size_t chunk_length) override {}
+  virtual void ProcessChunkExtensions(const char* input, size_t size) override {
   }
-  virtual void HeaderDone() OVERRIDE {}
-  virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE;
-  virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {}
-  virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE;
-  virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE;
+  virtual void HeaderDone() override {}
+  virtual void HandleHeaderError(BalsaFrame* framer) override;
+  virtual void HandleHeaderWarning(BalsaFrame* framer) override {}
+  virtual void HandleChunkingError(BalsaFrame* framer) override;
+  virtual void HandleBodyError(BalsaFrame* framer) override;
   void HandleError();
 
   SMConnection* connection_;
diff --git a/net/tools/gdig/file_net_log.h b/net/tools/gdig/file_net_log.h
index 0f858bb..005ea31 100644
--- a/net/tools/gdig/file_net_log.h
+++ b/net/tools/gdig/file_net_log.h
@@ -23,7 +23,7 @@
   virtual ~FileNetLogObserver();
 
   // NetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) override;
 
  private:
   FILE* const destination_;
diff --git a/net/tools/get_server_time/get_server_time.cc b/net/tools/get_server_time/get_server_time.cc
index ddc08b2..8ad907d 100644
--- a/net/tools/get_server_time/get_server_time.cc
+++ b/net/tools/get_server_time/get_server_time.cc
@@ -75,18 +75,18 @@
   virtual ~QuitDelegate() {}
 
   // net::URLFetcherDelegate implementation.
-  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE {
+  virtual void OnURLFetchComplete(const net::URLFetcher* source) override {
     base::MessageLoop::current()->Quit();
   }
 
   virtual void OnURLFetchDownloadProgress(
       const net::URLFetcher* source,
-      int64 current, int64 total) OVERRIDE {
+      int64 current, int64 total) override {
     NOTREACHED();
   }
 
   virtual void OnURLFetchUploadProgress(const net::URLFetcher* source,
-                                        int64 current, int64 total) OVERRIDE {
+                                        int64 current, int64 total) override {
     NOTREACHED();
   }
 
@@ -106,7 +106,7 @@
   }
 
   // NetLog::ThreadSafeObserver implementation:
-  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE {
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) override {
     // The log level of the entry is unknown, so just assume it maps
     // to VLOG(1).
     if (!VLOG_IS_ON(1))
diff --git a/net/tools/net_watcher/net_watcher.cc b/net/tools/net_watcher/net_watcher.cc
index 37c56a5..e9b3496 100644
--- a/net/tools/net_watcher/net_watcher.cc
+++ b/net/tools/net_watcher/net_watcher.cc
@@ -91,25 +91,25 @@
   virtual ~NetWatcher() {}
 
   // net::NetworkChangeNotifier::IPAddressObserver implementation.
-  virtual void OnIPAddressChanged() OVERRIDE {
+  virtual void OnIPAddressChanged() override {
     LOG(INFO) << "OnIPAddressChanged()";
   }
 
   // net::NetworkChangeNotifier::ConnectionTypeObserver implementation.
   virtual void OnConnectionTypeChanged(
-      net::NetworkChangeNotifier::ConnectionType type) OVERRIDE {
+      net::NetworkChangeNotifier::ConnectionType type) override {
     LOG(INFO) << "OnConnectionTypeChanged("
               << ConnectionTypeToString(type) << ")";
   }
 
   // net::NetworkChangeNotifier::DNSObserver implementation.
-  virtual void OnDNSChanged() OVERRIDE {
+  virtual void OnDNSChanged() override {
     LOG(INFO) << "OnDNSChanged()";
   }
 
   // net::NetworkChangeNotifier::NetworkChangeObserver implementation.
   virtual void OnNetworkChanged(
-      net::NetworkChangeNotifier::ConnectionType type) OVERRIDE {
+      net::NetworkChangeNotifier::ConnectionType type) override {
     LOG(INFO) << "OnNetworkChanged("
               << ConnectionTypeToString(type) << ")";
   }
@@ -117,7 +117,7 @@
   // net::ProxyConfigService::Observer implementation.
   virtual void OnProxyConfigChanged(
       const net::ProxyConfig& config,
-      net::ProxyConfigService::ConfigAvailability availability) OVERRIDE {
+      net::ProxyConfigService::ConfigAvailability availability) override {
     LOG(INFO) << "OnProxyConfigChanged("
               << ProxyConfigToString(config) << ", "
               << ConfigAvailabilityToString(availability) << ")";
diff --git a/net/tools/quic/end_to_end_test.cc b/net/tools/quic/end_to_end_test.cc
index b7d4c3d..f29af96 100644
--- a/net/tools/quic/end_to_end_test.cc
+++ b/net/tools/quic/end_to_end_test.cc
@@ -159,10 +159,10 @@
       : writer_factory_(writer_factory),
         dispatcher_(dispatcher) {}
   virtual ~ServerDelegate() {}
-  virtual void OnPacketSent(WriteResult result) OVERRIDE {
+  virtual void OnPacketSent(WriteResult result) override {
     writer_factory_->OnPacketSent(result);
   }
-  virtual void OnCanWrite() OVERRIDE { dispatcher_->OnCanWrite(); }
+  virtual void OnCanWrite() override { dispatcher_->OnCanWrite(); }
  private:
   TestWriterFactory* writer_factory_;
   QuicDispatcher* dispatcher_;
@@ -172,8 +172,8 @@
  public:
   explicit ClientDelegate(QuicClient* client) : client_(client) {}
   virtual ~ClientDelegate() {}
-  virtual void OnPacketSent(WriteResult result) OVERRIDE {}
-  virtual void OnCanWrite() OVERRIDE {
+  virtual void OnPacketSent(WriteResult result) override {}
+  virtual void OnCanWrite() override {
     EpollEvent event(EPOLLOUT, false);
     client_->OnEvent(client_->fd(), &event);
   }
@@ -198,9 +198,6 @@
 
     VLOG(1) << "Using Configuration: " << GetParam();
 
-    client_config_.SetDefaults();
-    server_config_.SetDefaults();
-
     // Use different flow control windows for client/server.
     client_config_.SetInitialFlowControlWindowToSend(
         2 * kInitialSessionFlowControlWindowForTest);
@@ -323,14 +320,14 @@
     return client_->client()->connected();
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     // The ownership of these gets transferred to the QuicPacketWriterWrapper
     // and TestWriterFactory when Initialize() is executed.
     client_writer_ = new PacketDroppingTestWriter();
     server_writer_ = new PacketDroppingTestWriter();
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     StopServer();
   }
 
@@ -1107,13 +1104,13 @@
       const char* buffer,
       size_t buf_len,
       const IPAddressNumber& real_self_address,
-      const IPEndPoint& peer_address) OVERRIDE {
+      const IPEndPoint& peer_address) override {
     // Use wrong address!
     return QuicPacketWriterWrapper::WritePacket(
         buffer, buf_len, self_address_.address(), peer_address);
   }
 
-  virtual bool IsWriteBlockedDataBuffered() const OVERRIDE {
+  virtual bool IsWriteBlockedDataBuffered() const override {
     return false;
   }
 
diff --git a/net/tools/quic/quic_client.cc b/net/tools/quic/quic_client.cc
index e70d8b8..7b2c994 100644
--- a/net/tools/quic/quic_client.cc
+++ b/net/tools/quic/quic_client.cc
@@ -49,7 +49,6 @@
       overflow_supported_(false),
       supported_versions_(supported_versions),
       print_response_(print_response) {
-  config_.SetDefaults();
 }
 
 QuicClient::QuicClient(IPEndPoint server_address,
@@ -86,7 +85,6 @@
   DCHECK(!initialized_);
 
   epoll_server_->set_timeout_in_us(50 * 1000);
-  crypto_config_.SetDefaults();
 
   if (!CreateUDPSocket()) {
     return false;
diff --git a/net/tools/quic/quic_client.h b/net/tools/quic/quic_client.h
index 8b0f1fe..ae5c2d9 100644
--- a/net/tools/quic/quic_client.h
+++ b/net/tools/quic/quic_client.h
@@ -107,17 +107,17 @@
   // From EpollCallbackInterface
   virtual void OnRegistration(EpollServer* eps,
                               int fd,
-                              int event_mask) OVERRIDE {}
-  virtual void OnModification(int fd, int event_mask) OVERRIDE {}
-  virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
+                              int event_mask) override {}
+  virtual void OnModification(int fd, int event_mask) override {}
+  virtual void OnEvent(int fd, EpollEvent* event) override;
   // |fd_| can be unregistered without the client being disconnected. This
   // happens in b3m QuicProber where we unregister |fd_| to feed in events to
   // the client from the SelectServer.
-  virtual void OnUnregistration(int fd, bool replaced) OVERRIDE {}
-  virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {}
+  virtual void OnUnregistration(int fd, bool replaced) override {}
+  virtual void OnShutdown(EpollServer* eps, int fd) override {}
 
   // QuicDataStream::Visitor
-  virtual void OnClose(QuicDataStream* stream) OVERRIDE;
+  virtual void OnClose(QuicDataStream* stream) override;
 
   QuicClientSession* session() { return session_.get(); }
 
@@ -194,7 +194,7 @@
     DummyPacketWriterFactory(QuicPacketWriter* writer);
     virtual ~DummyPacketWriterFactory();
 
-    virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE;
+    virtual QuicPacketWriter* Create(QuicConnection* connection) const override;
 
    private:
     QuicPacketWriter* writer_;
diff --git a/net/tools/quic/quic_client_bin.cc b/net/tools/quic/quic_client_bin.cc
index 4f76624..0f5c746 100644
--- a/net/tools/quic/quic_client_bin.cc
+++ b/net/tools/quic/quic_client_bin.cc
@@ -118,7 +118,6 @@
           << QuicVersionVectorToString(versions);
   net::EpollServer epoll_server;
   net::QuicConfig config;
-  config.SetDefaults();
 
   // The default flow control window of 16 Kb is too small for practical
   // purposes. Set it to the specified value, which has a large default.
diff --git a/net/tools/quic/quic_client_session.h b/net/tools/quic/quic_client_session.h
index bb64145..5e0624a 100644
--- a/net/tools/quic/quic_client_session.h
+++ b/net/tools/quic/quic_client_session.h
@@ -30,16 +30,16 @@
 
   // QuicClientSessionBase methods:
   virtual void OnProofValid(
-      const QuicCryptoClientConfig::CachedState& cached) OVERRIDE;
+      const QuicCryptoClientConfig::CachedState& cached) override;
   virtual void OnProofVerifyDetailsAvailable(
-      const ProofVerifyDetails& verify_details) OVERRIDE;
+      const ProofVerifyDetails& verify_details) override;
 
   void InitializeSession(const QuicServerId& server_id,
                          QuicCryptoClientConfig* config);
 
   // QuicSession methods:
-  virtual QuicSpdyClientStream* CreateOutgoingDataStream() OVERRIDE;
-  virtual QuicCryptoClientStream* GetCryptoStream() OVERRIDE;
+  virtual QuicSpdyClientStream* CreateOutgoingDataStream() override;
+  virtual QuicCryptoClientStream* GetCryptoStream() override;
 
   // Performs a crypto handshake with the server. Returns true if the crypto
   // handshake is started successfully.
@@ -52,7 +52,7 @@
 
  protected:
   // QuicSession methods:
-  virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE;
+  virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) override;
 
  private:
   scoped_ptr<QuicCryptoClientStream> crypto_stream_;
diff --git a/net/tools/quic/quic_client_session_test.cc b/net/tools/quic/quic_client_session_test.cc
index 2bd4315..8a78878 100644
--- a/net/tools/quic/quic_client_session_test.cc
+++ b/net/tools/quic/quic_client_session_test.cc
@@ -40,14 +40,12 @@
     : public ::testing::TestWithParam<QuicVersion> {
  protected:
   ToolsQuicClientSessionTest()
-      : connection_(new PacketSavingConnection(false,
-                                               SupportedVersions(GetParam()))) {
-    crypto_config_.SetDefaults();
+      : connection_(
+            new PacketSavingConnection(false, SupportedVersions(GetParam()))) {
     session_.reset(new QuicClientSession(DefaultQuicConfig(), connection_));
     session_->InitializeSession(
         QuicServerId(kServerHostname, kPort, false, PRIVACY_MODE_DISABLED),
         &crypto_config_);
-    session_->config()->SetDefaults();
   }
 
   void CompleteCryptoHandshake() {
@@ -74,8 +72,7 @@
   // Initialize crypto before the client session will create a stream.
   CompleteCryptoHandshake();
 
-  QuicSpdyClientStream* stream =
-      session_->CreateOutgoingDataStream();
+  QuicSpdyClientStream* stream = session_->CreateOutgoingDataStream();
   ASSERT_TRUE(stream);
   EXPECT_FALSE(session_->CreateOutgoingDataStream());
 
diff --git a/net/tools/quic/quic_default_packet_writer.h b/net/tools/quic/quic_default_packet_writer.h
index 7b5a36b..47925c3 100644
--- a/net/tools/quic/quic_default_packet_writer.h
+++ b/net/tools/quic/quic_default_packet_writer.h
@@ -25,10 +25,10 @@
   virtual WriteResult WritePacket(const char* buffer,
                                   size_t buf_len,
                                   const IPAddressNumber& self_address,
-                                  const IPEndPoint& peer_address) OVERRIDE;
-  virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
-  virtual bool IsWriteBlocked() const OVERRIDE;
-  virtual void SetWritable() OVERRIDE;
+                                  const IPEndPoint& peer_address) override;
+  virtual bool IsWriteBlockedDataBuffered() const override;
+  virtual bool IsWriteBlocked() const override;
+  virtual void SetWritable() override;
 
   void set_fd(int fd) { fd_ = fd; }
 
diff --git a/net/tools/quic/quic_dispatcher.cc b/net/tools/quic/quic_dispatcher.cc
index 11272e5..5f0e2da 100644
--- a/net/tools/quic/quic_dispatcher.cc
+++ b/net/tools/quic/quic_dispatcher.cc
@@ -32,7 +32,7 @@
       : dispatcher_(dispatcher) {
   }
 
-  virtual int64 OnAlarm() OVERRIDE {
+  virtual int64 OnAlarm() override {
     EpollAlarm::OnAlarm();
     dispatcher_->DeleteSessions();
     return 0;
@@ -49,23 +49,23 @@
         connection_id_(0) {}
 
   // QuicFramerVisitorInterface implementation
-  virtual void OnPacket() OVERRIDE {}
+  virtual void OnPacket() override {}
   virtual bool OnUnauthenticatedPublicHeader(
-      const QuicPacketPublicHeader& header) OVERRIDE {
+      const QuicPacketPublicHeader& header) override {
     connection_id_ = header.connection_id;
     return dispatcher_->OnUnauthenticatedPublicHeader(header);
   }
   virtual bool OnUnauthenticatedHeader(
-      const QuicPacketHeader& header) OVERRIDE {
+      const QuicPacketHeader& header) override {
     dispatcher_->OnUnauthenticatedHeader(header);
     return false;
   }
-  virtual void OnError(QuicFramer* framer) OVERRIDE {
+  virtual void OnError(QuicFramer* framer) override {
     DVLOG(1) << QuicUtils::ErrorToString(framer->error());
   }
 
   virtual bool OnProtocolVersionMismatch(
-      QuicVersion /*received_version*/) OVERRIDE {
+      QuicVersion /*received_version*/) override {
     if (dispatcher_->time_wait_list_manager()->IsConnectionIdInTimeWait(
             connection_id_)) {
       // Keep processing after protocol mismatch - this will be dealt with by
@@ -82,74 +82,74 @@
   // false from OnUnauthenticatedHeader().  As a result, we never process the
   // payload of the packet.
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& /*packet*/) OVERRIDE {
+      const QuicPublicResetPacket& /*packet*/) override {
     DCHECK(false);
   }
   virtual void OnVersionNegotiationPacket(
-      const QuicVersionNegotiationPacket& /*packet*/) OVERRIDE {
+      const QuicVersionNegotiationPacket& /*packet*/) override {
     DCHECK(false);
   }
-  virtual void OnDecryptedPacket(EncryptionLevel level) OVERRIDE {
+  virtual void OnDecryptedPacket(EncryptionLevel level) override {
     DCHECK(false);
   }
-  virtual bool OnPacketHeader(const QuicPacketHeader& /*header*/) OVERRIDE {
+  virtual bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
     DCHECK(false);
     return false;
   }
-  virtual void OnRevivedPacket() OVERRIDE {
+  virtual void OnRevivedPacket() override {
     DCHECK(false);
   }
-  virtual void OnFecProtectedPayload(StringPiece /*payload*/) OVERRIDE {
+  virtual void OnFecProtectedPayload(StringPiece /*payload*/) override {
     DCHECK(false);
   }
-  virtual bool OnStreamFrame(const QuicStreamFrame& /*frame*/) OVERRIDE {
+  virtual bool OnStreamFrame(const QuicStreamFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnAckFrame(const QuicAckFrame& /*frame*/) OVERRIDE {
+  virtual bool OnAckFrame(const QuicAckFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
   virtual bool OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& /*frame*/) OVERRIDE {
+      const QuicCongestionFeedbackFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
   virtual bool OnStopWaitingFrame(
-      const QuicStopWaitingFrame& /*frame*/) OVERRIDE {
+      const QuicStopWaitingFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnPingFrame(const QuicPingFrame& /*frame*/) OVERRIDE {
+  virtual bool OnPingFrame(const QuicPingFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) OVERRIDE {
+  virtual bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
   virtual bool OnConnectionCloseFrame(
-      const QuicConnectionCloseFrame & /*frame*/) OVERRIDE {
+      const QuicConnectionCloseFrame & /*frame*/) override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) OVERRIDE {
+  virtual bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) override {
     DCHECK(false);
     return false;
   }
   virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/)
-      OVERRIDE {
+      override {
     DCHECK(false);
     return false;
   }
-  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) OVERRIDE {
+  virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
     DCHECK(false);
     return false;
   }
-  virtual void OnFecData(const QuicFecData& /*fec*/) OVERRIDE {
+  virtual void OnFecData(const QuicFecData& /*fec*/) override {
     DCHECK(false);
   }
-  virtual void OnPacketComplete() OVERRIDE {
+  virtual void OnPacketComplete() override {
     DCHECK(false);
   }
 
diff --git a/net/tools/quic/quic_dispatcher.h b/net/tools/quic/quic_dispatcher.h
index ab8417c..8b0ab6d 100644
--- a/net/tools/quic/quic_dispatcher.h
+++ b/net/tools/quic/quic_dispatcher.h
@@ -68,7 +68,7 @@
 
     virtual QuicPacketWriter* Create(
         QuicPacketWriter* writer,
-        QuicConnection* connection) OVERRIDE;
+        QuicConnection* connection) override;
   };
 
   // Ideally we'd have a linked_hash_set: the  boolean is unused.
@@ -92,7 +92,7 @@
   // an existing session, or passing it to the TimeWaitListManager.
   virtual void ProcessPacket(const IPEndPoint& server_address,
                              const IPEndPoint& client_address,
-                             const QuicEncryptedPacket& packet) OVERRIDE;
+                             const QuicEncryptedPacket& packet) override;
 
   // Called when the socket becomes writable to allow queued writes to happen.
   virtual void OnCanWrite();
@@ -106,11 +106,11 @@
   // QuicServerSessionVisitor interface implementation:
   // Ensure that the closed connection is cleaned up asynchronously.
   virtual void OnConnectionClosed(QuicConnectionId connection_id,
-                                  QuicErrorCode error) OVERRIDE;
+                                  QuicErrorCode error) override;
 
   // Queues the blocked writer for later resumption.
   virtual void OnWriteBlocked(
-      QuicBlockedWriterInterface* blocked_writer) OVERRIDE;
+      QuicBlockedWriterInterface* blocked_writer) override;
 
   typedef base::hash_map<QuicConnectionId, QuicSession*> SessionMap;
 
@@ -193,7 +193,7 @@
     PacketWriterFactoryAdapter(QuicDispatcher* dispatcher);
     virtual ~PacketWriterFactoryAdapter ();
 
-    virtual QuicPacketWriter* Create(QuicConnection* connection) const OVERRIDE;
+    virtual QuicPacketWriter* Create(QuicConnection* connection) const override;
 
    private:
     QuicDispatcher* dispatcher_;
diff --git a/net/tools/quic/quic_dispatcher_test.cc b/net/tools/quic/quic_dispatcher_test.cc
index ac6fa70..bcbeb6a 100644
--- a/net/tools/quic/quic_dispatcher_test.cc
+++ b/net/tools/quic/quic_dispatcher_test.cc
@@ -264,14 +264,14 @@
  public:
   BlockingWriter() : write_blocked_(false) {}
 
-  virtual bool IsWriteBlocked() const OVERRIDE { return write_blocked_; }
-  virtual void SetWritable() OVERRIDE { write_blocked_ = false; }
+  virtual bool IsWriteBlocked() const override { return write_blocked_; }
+  virtual void SetWritable() override { write_blocked_ = false; }
 
   virtual WriteResult WritePacket(
       const char* buffer,
       size_t buf_len,
       const IPAddressNumber& self_client_address,
-      const IPEndPoint& peer_client_address) OVERRIDE {
+      const IPEndPoint& peer_client_address) override {
     // It would be quite possible to actually implement this method here with
     // the fake blocked status, but it would be significantly more work in
     // Chromium, and since it's not called anyway, don't bother.
diff --git a/net/tools/quic/quic_epoll_clock.h b/net/tools/quic/quic_epoll_clock.h
index d96bff6..4eebefb 100644
--- a/net/tools/quic/quic_epoll_clock.h
+++ b/net/tools/quic/quic_epoll_clock.h
@@ -24,11 +24,11 @@
   virtual ~QuicEpollClock();
 
   // Returns the approximate current time as a QuicTime object.
-  virtual QuicTime ApproximateNow() const OVERRIDE;
+  virtual QuicTime ApproximateNow() const override;
 
   // Returns the current time as a QuicTime object.
   // Note: this use significant resources please use only if needed.
-  virtual QuicTime Now() const OVERRIDE;
+  virtual QuicTime Now() const override;
 
  protected:
   EpollServer* epoll_server_;
diff --git a/net/tools/quic/quic_epoll_connection_helper.cc b/net/tools/quic/quic_epoll_connection_helper.cc
index 78bfe97..a8321f8 100644
--- a/net/tools/quic/quic_epoll_connection_helper.cc
+++ b/net/tools/quic/quic_epoll_connection_helper.cc
@@ -28,14 +28,14 @@
         epoll_alarm_impl_(this) {}
 
  protected:
-  virtual void SetImpl() OVERRIDE {
+  virtual void SetImpl() override {
     DCHECK(deadline().IsInitialized());
     epoll_server_->RegisterAlarm(
         deadline().Subtract(QuicTime::Zero()).ToMicroseconds(),
         &epoll_alarm_impl_);
   }
 
-  virtual void CancelImpl() OVERRIDE {
+  virtual void CancelImpl() override {
     DCHECK(!deadline().IsInitialized());
     epoll_alarm_impl_.UnregisterIfRegistered();
   }
@@ -45,7 +45,7 @@
    public:
     explicit EpollAlarmImpl(QuicEpollAlarm* alarm) : alarm_(alarm) {}
 
-    virtual int64 OnAlarm() OVERRIDE {
+    virtual int64 OnAlarm() override {
       EpollAlarm::OnAlarm();
       alarm_->Fire();
       // Fire will take care of registering the alarm, if needed.
diff --git a/net/tools/quic/quic_epoll_connection_helper.h b/net/tools/quic/quic_epoll_connection_helper.h
index 3198a14..9ca2cf8 100644
--- a/net/tools/quic/quic_epoll_connection_helper.h
+++ b/net/tools/quic/quic_epoll_connection_helper.h
@@ -36,9 +36,9 @@
   virtual ~QuicEpollConnectionHelper();
 
   // QuicEpollConnectionHelperInterface
-  virtual const QuicClock* GetClock() const OVERRIDE;
-  virtual QuicRandom* GetRandomGenerator() OVERRIDE;
-  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) OVERRIDE;
+  virtual const QuicClock* GetClock() const override;
+  virtual QuicRandom* GetRandomGenerator() override;
+  virtual QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
 
   EpollServer* epoll_server() { return epoll_server_; }
 
diff --git a/net/tools/quic/quic_epoll_connection_helper_test.cc b/net/tools/quic/quic_epoll_connection_helper_test.cc
index 708bdd4..7234ecf 100644
--- a/net/tools/quic/quic_epoll_connection_helper_test.cc
+++ b/net/tools/quic/quic_epoll_connection_helper_test.cc
@@ -19,7 +19,7 @@
  public:
   TestDelegate() : fired_(false) {}
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     fired_ = true;
     return QuicTime::Zero();
   }
diff --git a/net/tools/quic/quic_in_memory_cache.cc b/net/tools/quic/quic_in_memory_cache.cc
index 6754cf2..c90142c 100644
--- a/net/tools/quic/quic_in_memory_cache.cc
+++ b/net/tools/quic/quic_in_memory_cache.cc
@@ -29,22 +29,22 @@
 class CachingBalsaVisitor : public NoOpBalsaVisitor {
  public:
   CachingBalsaVisitor() : done_framing_(false) {}
-  virtual void ProcessBodyData(const char* input, size_t size) OVERRIDE {
+  virtual void ProcessBodyData(const char* input, size_t size) override {
     AppendToBody(input, size);
   }
-  virtual void MessageDone() OVERRIDE {
+  virtual void MessageDone() override {
     done_framing_ = true;
   }
-  virtual void HandleHeaderError(BalsaFrame* framer) OVERRIDE {
+  virtual void HandleHeaderError(BalsaFrame* framer) override {
     UnhandledError();
   }
-  virtual void HandleHeaderWarning(BalsaFrame* framer) OVERRIDE {
+  virtual void HandleHeaderWarning(BalsaFrame* framer) override {
     UnhandledError();
   }
-  virtual void HandleChunkingError(BalsaFrame* framer) OVERRIDE {
+  virtual void HandleChunkingError(BalsaFrame* framer) override {
     UnhandledError();
   }
-  virtual void HandleBodyError(BalsaFrame* framer) OVERRIDE {
+  virtual void HandleBodyError(BalsaFrame* framer) override {
     UnhandledError();
   }
   void UnhandledError() {
diff --git a/net/tools/quic/quic_in_memory_cache_test.cc b/net/tools/quic/quic_in_memory_cache_test.cc
index 9a75990..98a2b80 100644
--- a/net/tools/quic/quic_in_memory_cache_test.cc
+++ b/net/tools/quic/quic_in_memory_cache_test.cc
@@ -39,7 +39,7 @@
     headers->ReplaceOrAppendHeader("host", host);
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     QuicInMemoryCachePeer::ResetForTests();
   }
 
diff --git a/net/tools/quic/quic_packet_writer_wrapper.h b/net/tools/quic/quic_packet_writer_wrapper.h
index 9dafe77..a4db367 100644
--- a/net/tools/quic/quic_packet_writer_wrapper.h
+++ b/net/tools/quic/quic_packet_writer_wrapper.h
@@ -27,10 +27,10 @@
       const char* buffer,
       size_t buf_len,
       const IPAddressNumber& self_address,
-      const IPEndPoint& peer_address) OVERRIDE;
-  virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
-  virtual bool IsWriteBlocked() const OVERRIDE;
-  virtual void SetWritable() OVERRIDE;
+      const IPEndPoint& peer_address) override;
+  virtual bool IsWriteBlockedDataBuffered() const override;
+  virtual bool IsWriteBlocked() const override;
+  virtual void SetWritable() override;
 
   // Takes ownership of |writer|.
   void set_writer(QuicPacketWriter* writer);
diff --git a/net/tools/quic/quic_per_connection_packet_writer.h b/net/tools/quic/quic_per_connection_packet_writer.h
index a442a9a..390e43d 100644
--- a/net/tools/quic/quic_per_connection_packet_writer.h
+++ b/net/tools/quic/quic_per_connection_packet_writer.h
@@ -29,10 +29,10 @@
   virtual WriteResult WritePacket(const char* buffer,
                                   size_t buf_len,
                                   const IPAddressNumber& self_address,
-                                  const IPEndPoint& peer_address) OVERRIDE;
-  virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
-  virtual bool IsWriteBlocked() const OVERRIDE;
-  virtual void SetWritable() OVERRIDE;
+                                  const IPEndPoint& peer_address) override;
+  virtual bool IsWriteBlockedDataBuffered() const override;
+  virtual bool IsWriteBlocked() const override;
+  virtual void SetWritable() override;
 
  private:
   QuicPacketWriter* shared_writer_;  // Not owned.
diff --git a/net/tools/quic/quic_server.cc b/net/tools/quic/quic_server.cc
index 34beb3f..9d36909 100644
--- a/net/tools/quic/quic_server.cc
+++ b/net/tools/quic/quic_server.cc
@@ -48,8 +48,6 @@
       use_recvmmsg_(false),
       crypto_config_(kSourceAddressTokenSecret, QuicRandom::GetInstance()),
       supported_versions_(QuicSupportedVersions()) {
-  // Use hardcoded crypto parameters for now.
-  config_.SetDefaults();
   Initialize();
 }
 
diff --git a/net/tools/quic/quic_server.h b/net/tools/quic/quic_server.h
index 87c8bc7..a027a49 100644
--- a/net/tools/quic/quic_server.h
+++ b/net/tools/quic/quic_server.h
@@ -47,10 +47,10 @@
   // From EpollCallbackInterface
   virtual void OnRegistration(EpollServer* eps,
                               int fd,
-                              int event_mask) OVERRIDE {}
-  virtual void OnModification(int fd, int event_mask) OVERRIDE {}
-  virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
-  virtual void OnUnregistration(int fd, bool replaced) OVERRIDE {}
+                              int event_mask) override {}
+  virtual void OnModification(int fd, int event_mask) override {}
+  virtual void OnEvent(int fd, EpollEvent* event) override;
+  virtual void OnUnregistration(int fd, bool replaced) override {}
 
   // Reads a packet from the given fd, and then passes it off to
   // the QuicDispatcher.  Returns true if a packet is read, false
@@ -62,7 +62,7 @@
                                           ProcessPacketInterface* processor,
                                           uint32* packets_dropped);
 
-  virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {}
+  virtual void OnShutdown(EpollServer* eps, int fd) override {}
 
   void SetStrikeRegisterNoStartupPeriod() {
     crypto_config_.set_strike_register_no_startup_period();
diff --git a/net/tools/quic/quic_server_session.cc b/net/tools/quic/quic_server_session.cc
index cb56329..842c6ef 100644
--- a/net/tools/quic/quic_server_session.cc
+++ b/net/tools/quic/quic_server_session.cc
@@ -134,7 +134,7 @@
     cached_network_params.set_serving_region(serving_region_);
   }
 
-  crypto_stream_->SendServerConfigUpdate(&cached_network_params);
+  crypto_stream_->SendServerConfigUpdate(&cached_network_params, false);
   last_server_config_update_time_ = now;
 }
 
diff --git a/net/tools/quic/quic_server_session.h b/net/tools/quic/quic_server_session.h
index 87f82d9..eb0aab6 100644
--- a/net/tools/quic/quic_server_session.h
+++ b/net/tools/quic/quic_server_session.h
@@ -50,12 +50,12 @@
                     QuicServerSessionVisitor* visitor);
 
   // Override the base class to notify the owner of the connection close.
-  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) OVERRIDE;
-  virtual void OnWriteBlocked() OVERRIDE;
+  virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer) override;
+  virtual void OnWriteBlocked() override;
 
   // Sends a server config update to the client, containing new bandwidth
   // estimate.
-  virtual void OnCongestionWindowChange(QuicTime now) OVERRIDE;
+  virtual void OnCongestionWindowChange(QuicTime now) override;
 
   virtual ~QuicServerSession();
 
@@ -66,7 +66,7 @@
   }
 
   // Override base class to process FEC config received from client.
-  virtual void OnConfigNegotiated() OVERRIDE;
+  virtual void OnConfigNegotiated() override;
 
   void set_serving_region(string serving_region) {
     serving_region_ = serving_region;
@@ -74,9 +74,9 @@
 
  protected:
   // QuicSession methods:
-  virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE;
-  virtual QuicDataStream* CreateOutgoingDataStream() OVERRIDE;
-  virtual QuicCryptoServerStream* GetCryptoStream() OVERRIDE;
+  virtual QuicDataStream* CreateIncomingDataStream(QuicStreamId id) override;
+  virtual QuicDataStream* CreateOutgoingDataStream() override;
+  virtual QuicCryptoServerStream* GetCryptoStream() override;
 
   // If we should create an incoming stream, returns true. Otherwise
   // does error handling, including communicating the error to the client and
diff --git a/net/tools/quic/quic_server_session_test.cc b/net/tools/quic/quic_server_session_test.cc
index 4fc4157..72c65a8 100644
--- a/net/tools/quic/quic_server_session_test.cc
+++ b/net/tools/quic/quic_server_session_test.cc
@@ -68,7 +68,6 @@
   QuicServerSessionTest()
       : crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance()) {
-    config_.SetDefaults();
     config_.SetMaxStreamsPerConnection(kMaxStreamsForTest,
                                        kMaxStreamsForTest);
     config_.SetInitialFlowControlWindowToSend(
@@ -295,8 +294,10 @@
       : QuicCryptoServerStream(crypto_config, session) {}
   virtual ~MockQuicCryptoServerStream() {}
 
-  MOCK_METHOD1(SendServerConfigUpdate,
-               void(const CachedNetworkParameters* cached_network_parameters));
+  MOCK_METHOD2(SendServerConfigUpdate,
+               void(const CachedNetworkParameters* cached_network_parameters,
+                    bool on_handshake_complete));
+
  private:
   DISALLOW_COPY_AND_ASSIGN(MockQuicCryptoServerStream);
 };
@@ -365,7 +366,7 @@
   expected_network_params.set_serving_region(serving_region);
 
   EXPECT_CALL(*crypto_stream,
-              SendServerConfigUpdate(EqualsProto(expected_network_params)))
+              SendServerConfigUpdate(EqualsProto(expected_network_params), _))
       .Times(1);
   session_->OnCongestionWindowChange(now);
 }
diff --git a/net/tools/quic/quic_spdy_client_stream.h b/net/tools/quic/quic_spdy_client_stream.h
index 7bbdee6..8274164 100644
--- a/net/tools/quic/quic_spdy_client_stream.h
+++ b/net/tools/quic/quic_spdy_client_stream.h
@@ -32,16 +32,16 @@
   // Override the base class to close the write side as soon as we get a
   // response.
   // SPDY/HTTP does not support bidirectional streaming.
-  virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
+  virtual void OnStreamFrame(const QuicStreamFrame& frame) override;
 
   // Override the base class to store the size of the headers.
-  virtual void OnStreamHeadersComplete(bool fin, size_t frame_len) OVERRIDE;
+  virtual void OnStreamHeadersComplete(bool fin, size_t frame_len) override;
 
   // ReliableQuicStream implementation called by the session when there's
   // data for us.
-  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE;
+  virtual uint32 ProcessData(const char* data, uint32 data_len) override;
 
-  virtual void OnFinRead() OVERRIDE;
+  virtual void OnFinRead() override;
 
   // Serializes the headers and body, sends it to the server, and
   // returns the number of bytes sent.
diff --git a/net/tools/quic/quic_spdy_client_stream_test.cc b/net/tools/quic/quic_spdy_client_stream_test.cc
index 058b204..090e2da 100644
--- a/net/tools/quic/quic_spdy_client_stream_test.cc
+++ b/net/tools/quic/quic_spdy_client_stream_test.cc
@@ -34,7 +34,6 @@
     session_.InitializeSession(
         QuicServerId("example.com", 80, false, PRIVACY_MODE_DISABLED),
         &crypto_config_);
-    crypto_config_.SetDefaults();
 
     headers_.SetResponseFirstlineFromStringPieces("HTTP/1.1", "200", "Ok");
     headers_.ReplaceOrAppendHeader("content-length", "11");
diff --git a/net/tools/quic/quic_spdy_server_stream.h b/net/tools/quic/quic_spdy_server_stream.h
index c8167d1..4c2cb41 100644
--- a/net/tools/quic/quic_spdy_server_stream.h
+++ b/net/tools/quic/quic_spdy_server_stream.h
@@ -32,8 +32,8 @@
 
   // ReliableQuicStream implementation called by the session when there's
   // data for us.
-  virtual uint32 ProcessData(const char* data, uint32 data_len) OVERRIDE;
-  virtual void OnFinRead() OVERRIDE;
+  virtual uint32 ProcessData(const char* data, uint32 data_len) override;
+  virtual void OnFinRead() override;
 
   void ParseRequestHeaders();
 
diff --git a/net/tools/quic/quic_spdy_server_stream_test.cc b/net/tools/quic/quic_spdy_server_stream_test.cc
index f5bd17f..4f5484a 100644
--- a/net/tools/quic/quic_spdy_server_stream_test.cc
+++ b/net/tools/quic/quic_spdy_server_stream_test.cc
@@ -97,7 +97,7 @@
     QuicInMemoryCachePeer::ResetForTests();
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     QuicInMemoryCache* cache = QuicInMemoryCache::GetInstance();
 
     BalsaHeaders request_headers, response_headers;
diff --git a/net/tools/quic/quic_time_wait_list_manager.cc b/net/tools/quic/quic_time_wait_list_manager.cc
index 9744ff8..f99bf3f 100644
--- a/net/tools/quic/quic_time_wait_list_manager.cc
+++ b/net/tools/quic/quic_time_wait_list_manager.cc
@@ -43,7 +43,7 @@
       : time_wait_list_manager_(time_wait_list_manager) {
   }
 
-  virtual int64 OnAlarm() OVERRIDE {
+  virtual int64 OnAlarm() override {
     EpollAlarm::OnAlarm();
     time_wait_list_manager_->CleanUpOldConnectionIds();
     // Let the time wait manager register the alarm at appropriate time.
diff --git a/net/tools/quic/quic_time_wait_list_manager.h b/net/tools/quic/quic_time_wait_list_manager.h
index 1af9d56..d9a5f92 100644
--- a/net/tools/quic/quic_time_wait_list_manager.h
+++ b/net/tools/quic/quic_time_wait_list_manager.h
@@ -83,7 +83,7 @@
   // Called by the dispatcher when the underlying socket becomes writable again,
   // since we might need to send pending public reset packets which we didn't
   // send because the underlying socket was write blocked.
-  virtual void OnCanWrite() OVERRIDE;
+  virtual void OnCanWrite() override;
 
   // Used to delete connection_id entries that have outlived their time wait
   // period.
diff --git a/net/tools/quic/quic_time_wait_list_manager_test.cc b/net/tools/quic/quic_time_wait_list_manager_test.cc
index 5e964d6..335b22c 100644
--- a/net/tools/quic/quic_time_wait_list_manager_test.cc
+++ b/net/tools/quic/quic_time_wait_list_manager_test.cc
@@ -45,10 +45,10 @@
 class FramerVisitorCapturingPublicReset : public NoOpFramerVisitor {
  public:
   FramerVisitorCapturingPublicReset() {}
-  virtual ~FramerVisitorCapturingPublicReset() OVERRIDE {}
+  virtual ~FramerVisitorCapturingPublicReset() override {}
 
   virtual void OnPublicResetPacket(
-      const QuicPublicResetPacket& public_reset) OVERRIDE {
+      const QuicPublicResetPacket& public_reset) override {
     public_reset_packet_ = public_reset;
   }
 
@@ -96,9 +96,9 @@
         client_address_(net::test::TestPeerIPAddress(), kTestPort),
         writer_is_blocked_(false) {}
 
-  virtual ~QuicTimeWaitListManagerTest() OVERRIDE {}
+  virtual ~QuicTimeWaitListManagerTest() override {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     EXPECT_CALL(writer_, IsWriteBlocked())
         .WillRepeatedly(ReturnPointee(&writer_is_blocked_));
     EXPECT_CALL(writer_, IsWriteBlockedDataBuffered())
@@ -181,7 +181,7 @@
 
   virtual bool MatchAndExplain(
       const std::tr1::tuple<const char*, int> packet_buffer,
-      testing::MatchResultListener* /* listener */) const OVERRIDE {
+      testing::MatchResultListener* /* listener */) const override {
     FramerVisitorCapturingPublicReset visitor;
     QuicFramer framer(QuicSupportedVersions(),
                       QuicTime::Zero(),
@@ -198,9 +198,9 @@
         kTestPort == packet.client_address.port();
   }
 
-  virtual void DescribeTo(::std::ostream* os) const OVERRIDE {}
+  virtual void DescribeTo(::std::ostream* os) const override {}
 
-  virtual void DescribeNegationTo(::std::ostream* os) const OVERRIDE {}
+  virtual void DescribeNegationTo(::std::ostream* os) const override {}
 
  private:
   QuicConnectionId connection_id_;
diff --git a/net/tools/quic/test_tools/mock_epoll_server.h b/net/tools/quic/test_tools/mock_epoll_server.h
index cdb6a36..b3b312e 100644
--- a/net/tools/quic/test_tools/mock_epoll_server.h
+++ b/net/tools/quic/test_tools/mock_epoll_server.h
@@ -22,7 +22,7 @@
   virtual ~FakeTimeEpollServer();
 
   // Replaces the EpollServer NowInUsec.
-  virtual int64 NowInUsec() const OVERRIDE;
+  virtual int64 NowInUsec() const override;
 
   void set_now_in_usec(int64 nius) { now_in_usec_ = nius; }
 
@@ -85,16 +85,16 @@
  protected:  // functions
   // These functions do nothing here, as we're not actually
   // using the epoll_* syscalls.
-  virtual void DelFD(int fd) const OVERRIDE {}
-  virtual void AddFD(int fd, int event_mask) const OVERRIDE {}
-  virtual void ModFD(int fd, int event_mask) const OVERRIDE {}
+  virtual void DelFD(int fd) const override {}
+  virtual void AddFD(int fd, int event_mask) const override {}
+  virtual void ModFD(int fd, int event_mask) const override {}
 
   // Replaces the epoll_server's epoll_wait_impl.
   virtual int epoll_wait_impl(int epfd,
                               struct epoll_event* events,
                               int max_events,
-                              int timeout_in_ms) OVERRIDE;
-  virtual void SetNonblocking (int fd) OVERRIDE {}
+                              int timeout_in_ms) override;
+  virtual void SetNonblocking (int fd) override {}
 
  private:  // members
   EventQueue event_queue_;
diff --git a/net/tools/quic/test_tools/packet_dropping_test_writer.cc b/net/tools/quic/test_tools/packet_dropping_test_writer.cc
index c7202d6..2571868 100644
--- a/net/tools/quic/test_tools/packet_dropping_test_writer.cc
+++ b/net/tools/quic/test_tools/packet_dropping_test_writer.cc
@@ -21,7 +21,7 @@
   explicit WriteUnblockedAlarm(PacketDroppingTestWriter* writer)
       : writer_(writer) {}
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     DVLOG(1) << "Unblocking socket.";
     writer_->OnCanWrite();
     return QuicTime::Zero();
@@ -37,7 +37,7 @@
  public:
   explicit DelayAlarm(PacketDroppingTestWriter* writer) : writer_(writer) {}
 
-  virtual QuicTime OnAlarm() OVERRIDE {
+  virtual QuicTime OnAlarm() override {
     return writer_->ReleaseOldPackets();
   }
 
diff --git a/net/tools/quic/test_tools/packet_dropping_test_writer.h b/net/tools/quic/test_tools/packet_dropping_test_writer.h
index b7babad..29a21a8 100644
--- a/net/tools/quic/test_tools/packet_dropping_test_writer.h
+++ b/net/tools/quic/test_tools/packet_dropping_test_writer.h
@@ -49,11 +49,11 @@
       const char* buffer,
       size_t buf_len,
       const IPAddressNumber& self_address,
-      const IPEndPoint& peer_address) OVERRIDE;
+      const IPEndPoint& peer_address) override;
 
-  virtual bool IsWriteBlocked() const OVERRIDE;
+  virtual bool IsWriteBlocked() const override;
 
-  virtual void SetWritable() OVERRIDE;
+  virtual void SetWritable() override;
 
   // Writes out any packet which should have been sent by now
   // to the contained writer and returns the time
diff --git a/net/tools/quic/test_tools/quic_test_client.cc b/net/tools/quic/test_tools/quic_test_client.cc
index 68b8698..d53958d 100644
--- a/net/tools/quic/test_tools/quic_test_client.cc
+++ b/net/tools/quic/test_tools/quic_test_client.cc
@@ -49,7 +49,7 @@
       const ProofVerifyContext* context,
       string* error_details,
       scoped_ptr<ProofVerifyDetails>* details,
-      ProofVerifierCallback* callback) OVERRIDE {
+      ProofVerifierCallback* callback) override {
     common_name_.clear();
     if (certs.empty()) {
       return QUIC_FAILURE;
diff --git a/net/tools/quic/test_tools/quic_test_client.h b/net/tools/quic/test_tools/quic_test_client.h
index 7ae3b74..c9fd22e 100644
--- a/net/tools/quic/test_tools/quic_test_client.h
+++ b/net/tools/quic/test_tools/quic_test_client.h
@@ -45,9 +45,9 @@
                      const QuicVersionVector& supported_versions,
                      EpollServer* epoll_server);
 
-  virtual ~MockableQuicClient() OVERRIDE;
-  virtual QuicPacketWriter* CreateQuicPacketWriter() OVERRIDE;
-  virtual QuicConnectionId GenerateConnectionId() OVERRIDE;
+  virtual ~MockableQuicClient() override;
+  virtual QuicPacketWriter* CreateQuicPacketWriter() override;
+  virtual QuicConnectionId GenerateConnectionId() override;
   void UseWriter(QuicPacketWriterWrapper* writer);
   void UseConnectionId(QuicConnectionId connection_id);
 
@@ -91,45 +91,45 @@
   // From SimpleClient
   // Clears any outstanding state and sends a simple GET of 'uri' to the
   // server.  Returns 0 if the request failed and no bytes were written.
-  virtual ssize_t SendRequest(const string& uri) OVERRIDE;
-  virtual ssize_t SendMessage(const HTTPMessage& message) OVERRIDE;
+  virtual ssize_t SendRequest(const string& uri) override;
+  virtual ssize_t SendMessage(const HTTPMessage& message) override;
   virtual string SendCustomSynchronousRequest(
-      const HTTPMessage& message) OVERRIDE;
-  virtual string SendSynchronousRequest(const string& uri) OVERRIDE;
-  virtual void Connect() OVERRIDE;
-  virtual void ResetConnection() OVERRIDE;
-  virtual void Disconnect() OVERRIDE;
-  virtual IPEndPoint LocalSocketAddress() const OVERRIDE;
-  virtual void ClearPerRequestState() OVERRIDE;
-  virtual void WaitForResponseForMs(int timeout_ms) OVERRIDE;
-  virtual void WaitForInitialResponseForMs(int timeout_ms) OVERRIDE;
-  virtual ssize_t Send(const void *buffer, size_t size) OVERRIDE;
-  virtual bool response_complete() const OVERRIDE;
-  virtual bool response_headers_complete() const OVERRIDE;
-  virtual const BalsaHeaders* response_headers() const OVERRIDE;
-  virtual int64 response_size() const OVERRIDE;
-  virtual int response_header_size() const OVERRIDE;
-  virtual int64 response_body_size() const OVERRIDE;
-  virtual size_t bytes_read() const OVERRIDE;
-  virtual size_t bytes_written() const OVERRIDE;
-  virtual bool buffer_body() const OVERRIDE;
-  virtual void set_buffer_body(bool buffer_body) OVERRIDE;
-  virtual bool ServerInLameDuckMode() const OVERRIDE;
-  virtual const string& response_body() OVERRIDE;
-  virtual bool connected() const OVERRIDE;
+      const HTTPMessage& message) override;
+  virtual string SendSynchronousRequest(const string& uri) override;
+  virtual void Connect() override;
+  virtual void ResetConnection() override;
+  virtual void Disconnect() override;
+  virtual IPEndPoint LocalSocketAddress() const override;
+  virtual void ClearPerRequestState() override;
+  virtual void WaitForResponseForMs(int timeout_ms) override;
+  virtual void WaitForInitialResponseForMs(int timeout_ms) override;
+  virtual ssize_t Send(const void *buffer, size_t size) override;
+  virtual bool response_complete() const override;
+  virtual bool response_headers_complete() const override;
+  virtual const BalsaHeaders* response_headers() const override;
+  virtual int64 response_size() const override;
+  virtual int response_header_size() const override;
+  virtual int64 response_body_size() const override;
+  virtual size_t bytes_read() const override;
+  virtual size_t bytes_written() const override;
+  virtual bool buffer_body() const override;
+  virtual void set_buffer_body(bool buffer_body) override;
+  virtual bool ServerInLameDuckMode() const override;
+  virtual const string& response_body() override;
+  virtual bool connected() const override;
   // These functions are all unimplemented functions from SimpleClient, and log
   // DFATAL if called by users of SimpleClient.
   virtual ssize_t SendAndWaitForResponse(const void *buffer,
-                                         size_t size) OVERRIDE;
-  virtual void Bind(IPEndPoint* local_address) OVERRIDE;
-  virtual string SerializeMessage(const HTTPMessage& message) OVERRIDE;
-  virtual IPAddressNumber bind_to_address() const OVERRIDE;
-  virtual void set_bind_to_address(IPAddressNumber address) OVERRIDE;
-  virtual const IPEndPoint& address() const OVERRIDE;
-  virtual size_t requests_sent() const OVERRIDE;
+                                         size_t size) override;
+  virtual void Bind(IPEndPoint* local_address) override;
+  virtual string SerializeMessage(const HTTPMessage& message) override;
+  virtual IPAddressNumber bind_to_address() const override;
+  virtual void set_bind_to_address(IPAddressNumber address) override;
+  virtual const IPEndPoint& address() const override;
+  virtual size_t requests_sent() const override;
 
   // From QuicDataStream::Visitor
-  virtual void OnClose(QuicDataStream* stream) OVERRIDE;
+  virtual void OnClose(QuicDataStream* stream) override;
 
   // Configures client_ to take ownership of and use the writer.
   // Must be called before initial connect.
diff --git a/net/tools/quic/test_tools/quic_test_utils.cc b/net/tools/quic/test_tools/quic_test_utils.cc
index 8fdbe00..781b3c3 100644
--- a/net/tools/quic/test_tools/quic_test_utils.cc
+++ b/net/tools/quic/test_tools/quic_test_utils.cc
@@ -26,7 +26,7 @@
   virtual ~NiceMockPacketWriterFactory() {}
 
   virtual QuicPacketWriter* Create(
-      QuicConnection* /*connection*/) const OVERRIDE {
+      QuicConnection* /*connection*/) const override {
     return new testing::NiceMock<MockPacketWriter>();
   }
 
diff --git a/net/tools/quic/test_tools/quic_test_utils.h b/net/tools/quic/test_tools/quic_test_utils.h
index 1211ff2..dc70e69 100644
--- a/net/tools/quic/test_tools/quic_test_utils.h
+++ b/net/tools/quic/test_tools/quic_test_utils.h
@@ -104,7 +104,7 @@
 
   void SetCryptoStream(QuicCryptoStream* stream);
 
-  virtual QuicCryptoStream* GetCryptoStream() OVERRIDE;
+  virtual QuicCryptoStream* GetCryptoStream() override;
 
  private:
   QuicCryptoStream* crypto_stream_;
@@ -169,7 +169,7 @@
   virtual ~TestWriterFactory();
 
   virtual QuicPacketWriter* Create(QuicPacketWriter* writer,
-                                   QuicConnection* connection) OVERRIDE;
+                                   QuicConnection* connection) override;
 
   // Calls OnPacketSent on the last QuicConnection to write through one of the
   // packet writers created by this factory.
@@ -187,7 +187,7 @@
         const char* buffer,
         size_t buf_len,
         const IPAddressNumber& self_address,
-        const IPEndPoint& peer_address) OVERRIDE;
+        const IPEndPoint& peer_address) override;
 
    private:
     TestWriterFactory* factory_;
diff --git a/net/tools/quic/test_tools/server_thread.h b/net/tools/quic/test_tools/server_thread.h
index 6066d97..cb92b01 100644
--- a/net/tools/quic/test_tools/server_thread.h
+++ b/net/tools/quic/test_tools/server_thread.h
@@ -28,7 +28,7 @@
   void Initialize();
 
   // Runs the event loop. Will initialize if necessary.
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
   // Waits for the handshake to be confirmed for the first session created.
   void WaitForCryptoHandshakeConfirmed();
diff --git a/net/udp/udp_client_socket.h b/net/udp/udp_client_socket.h
index c5fc8c0..d689640 100644
--- a/net/udp/udp_client_socket.h
+++ b/net/udp/udp_client_socket.h
@@ -24,17 +24,17 @@
   virtual ~UDPClientSocket();
 
   // DatagramClientSocket implementation.
-  virtual int Connect(const IPEndPoint& address) OVERRIDE;
+  virtual int Connect(const IPEndPoint& address) override;
   virtual int Read(IOBuffer* buf, int buf_len,
-                   const CompletionCallback& callback) OVERRIDE;
+                   const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buf, int buf_len,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual void Close() override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
+  virtual const BoundNetLog& NetLog() const override;
 
  private:
   UDPSocket socket_;
diff --git a/net/udp/udp_server_socket.h b/net/udp/udp_server_socket.h
index 4ce7354..9801ff8 100644
--- a/net/udp/udp_server_socket.h
+++ b/net/udp/udp_server_socket.h
@@ -22,30 +22,30 @@
   virtual ~UDPServerSocket();
 
   // Implement DatagramServerSocket:
-  virtual int Listen(const IPEndPoint& address) OVERRIDE;
+  virtual int Listen(const IPEndPoint& address) override;
   virtual int RecvFrom(IOBuffer* buf,
                        int buf_len,
                        IPEndPoint* address,
-                       const CompletionCallback& callback) OVERRIDE;
+                       const CompletionCallback& callback) override;
   virtual int SendTo(IOBuffer* buf,
                      int buf_len,
                      const IPEndPoint& address,
-                     const CompletionCallback& callback) OVERRIDE;
-  virtual int SetReceiveBufferSize(int32 size) OVERRIDE;
-  virtual int SetSendBufferSize(int32 size) OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE;
-  virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE;
-  virtual const BoundNetLog& NetLog() const OVERRIDE;
-  virtual void AllowAddressReuse() OVERRIDE;
-  virtual void AllowBroadcast() OVERRIDE;
-  virtual int JoinGroup(const IPAddressNumber& group_address) const OVERRIDE;
-  virtual int LeaveGroup(const IPAddressNumber& group_address) const OVERRIDE;
-  virtual int SetMulticastInterface(uint32 interface_index) OVERRIDE;
-  virtual int SetMulticastTimeToLive(int time_to_live) OVERRIDE;
-  virtual int SetMulticastLoopbackMode(bool loopback) OVERRIDE;
-  virtual int SetDiffServCodePoint(DiffServCodePoint dscp) OVERRIDE;
-  virtual void DetachFromThread() OVERRIDE;
+                     const CompletionCallback& callback) override;
+  virtual int SetReceiveBufferSize(int32 size) override;
+  virtual int SetSendBufferSize(int32 size) override;
+  virtual void Close() override;
+  virtual int GetPeerAddress(IPEndPoint* address) const override;
+  virtual int GetLocalAddress(IPEndPoint* address) const override;
+  virtual const BoundNetLog& NetLog() const override;
+  virtual void AllowAddressReuse() override;
+  virtual void AllowBroadcast() override;
+  virtual int JoinGroup(const IPAddressNumber& group_address) const override;
+  virtual int LeaveGroup(const IPAddressNumber& group_address) const override;
+  virtual int SetMulticastInterface(uint32 interface_index) override;
+  virtual int SetMulticastTimeToLive(int time_to_live) override;
+  virtual int SetMulticastLoopbackMode(bool loopback) override;
+  virtual int SetDiffServCodePoint(DiffServCodePoint dscp) override;
+  virtual void DetachFromThread() override;
 
  private:
   UDPSocket socket_;
diff --git a/net/udp/udp_socket_libevent.h b/net/udp/udp_socket_libevent.h
index 69e8ba3..292a42f 100644
--- a/net/udp/udp_socket_libevent.h
+++ b/net/udp/udp_socket_libevent.h
@@ -179,9 +179,9 @@
 
     // MessageLoopForIO::Watcher methods
 
-    virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE;
+    virtual void OnFileCanReadWithoutBlocking(int /* fd */) override;
 
-    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE {}
+    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override {}
 
    private:
     UDPSocketLibevent* const socket_;
@@ -195,9 +195,9 @@
 
     // MessageLoopForIO::Watcher methods
 
-    virtual void OnFileCanReadWithoutBlocking(int /* fd */) OVERRIDE {}
+    virtual void OnFileCanReadWithoutBlocking(int /* fd */) override {}
 
-    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) OVERRIDE;
+    virtual void OnFileCanWriteWithoutBlocking(int /* fd */) override;
 
    private:
     UDPSocketLibevent* const socket_;
diff --git a/net/url_request/data_protocol_handler.h b/net/url_request/data_protocol_handler.h
index b7f7fef..3c2c4d4 100644
--- a/net/url_request/data_protocol_handler.h
+++ b/net/url_request/data_protocol_handler.h
@@ -19,8 +19,8 @@
  public:
   DataProtocolHandler();
   virtual URLRequestJob* MaybeCreateJob(
-      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+      URLRequest* request, NetworkDelegate* network_delegate) const override;
+  virtual bool IsSafeRedirectTarget(const GURL& location) const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DataProtocolHandler);
diff --git a/net/url_request/file_protocol_handler.h b/net/url_request/file_protocol_handler.h
index 78956a9..02b5c9f 100644
--- a/net/url_request/file_protocol_handler.h
+++ b/net/url_request/file_protocol_handler.h
@@ -30,8 +30,8 @@
       const scoped_refptr<base::TaskRunner>& file_task_runner);
   virtual ~FileProtocolHandler();
   virtual URLRequestJob* MaybeCreateJob(
-      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+      URLRequest* request, NetworkDelegate* network_delegate) const override;
+  virtual bool IsSafeRedirectTarget(const GURL& location) const override;
 
  private:
   const scoped_refptr<base::TaskRunner> file_task_runner_;
diff --git a/net/url_request/ftp_protocol_handler.h b/net/url_request/ftp_protocol_handler.h
index 7c2278a..c3091b9 100644
--- a/net/url_request/ftp_protocol_handler.h
+++ b/net/url_request/ftp_protocol_handler.h
@@ -24,7 +24,7 @@
   explicit FtpProtocolHandler(FtpTransactionFactory* ftp_transaction_factory);
   virtual ~FtpProtocolHandler();
   virtual URLRequestJob* MaybeCreateJob(
-      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE;
+      URLRequest* request, NetworkDelegate* network_delegate) const override;
 
  private:
   friend class FtpTestURLRequestContext;
diff --git a/net/url_request/static_http_user_agent_settings.h b/net/url_request/static_http_user_agent_settings.h
index 7406abc..4edb948 100644
--- a/net/url_request/static_http_user_agent_settings.h
+++ b/net/url_request/static_http_user_agent_settings.h
@@ -23,8 +23,8 @@
   virtual ~StaticHttpUserAgentSettings();
 
   // HttpUserAgentSettings implementation
-  virtual std::string GetAcceptLanguage() const OVERRIDE;
-  virtual std::string GetUserAgent() const OVERRIDE;
+  virtual std::string GetAcceptLanguage() const override;
+  virtual std::string GetUserAgent() const override;
 
  private:
   const std::string accept_language_;
diff --git a/net/url_request/test_url_fetcher_factory.h b/net/url_request/test_url_fetcher_factory.h
index 5d4f3d9..c004ce7 100644
--- a/net/url_request/test_url_fetcher_factory.h
+++ b/net/url_request/test_url_fetcher_factory.h
@@ -88,66 +88,66 @@
 
   // URLFetcher implementation
   virtual void SetUploadData(const std::string& upload_content_type,
-                             const std::string& upload_content) OVERRIDE;
+                             const std::string& upload_content) override;
   virtual void SetUploadFilePath(
       const std::string& upload_content_type,
       const base::FilePath& file_path,
       uint64 range_offset,
       uint64 range_length,
-      scoped_refptr<base::TaskRunner> file_task_runner) OVERRIDE;
+      scoped_refptr<base::TaskRunner> file_task_runner) override;
   virtual void SetChunkedUpload(
-      const std::string& upload_content_type) OVERRIDE;
+      const std::string& upload_content_type) override;
   // Overriden to cache the chunks uploaded. Caller can read back the uploaded
   // chunks with the upload_chunks() accessor.
   virtual void AppendChunkToUpload(const std::string& data,
-                                   bool is_last_chunk) OVERRIDE;
-  virtual void SetLoadFlags(int load_flags) OVERRIDE;
-  virtual int GetLoadFlags() const OVERRIDE;
-  virtual void SetReferrer(const std::string& referrer) OVERRIDE;
+                                   bool is_last_chunk) override;
+  virtual void SetLoadFlags(int load_flags) override;
+  virtual int GetLoadFlags() const override;
+  virtual void SetReferrer(const std::string& referrer) override;
   virtual void SetReferrerPolicy(
-      URLRequest::ReferrerPolicy referrer_policy) OVERRIDE;
+      URLRequest::ReferrerPolicy referrer_policy) override;
   virtual void SetExtraRequestHeaders(
-      const std::string& extra_request_headers) OVERRIDE;
-  virtual void AddExtraRequestHeader(const std::string& header_line) OVERRIDE;
+      const std::string& extra_request_headers) override;
+  virtual void AddExtraRequestHeader(const std::string& header_line) override;
   virtual void SetRequestContext(
-      URLRequestContextGetter* request_context_getter) OVERRIDE;
+      URLRequestContextGetter* request_context_getter) override;
   virtual void SetFirstPartyForCookies(
-      const GURL& first_party_for_cookies) OVERRIDE;
+      const GURL& first_party_for_cookies) override;
   virtual void SetURLRequestUserData(
       const void* key,
-      const CreateDataCallback& create_data_callback) OVERRIDE;
-  virtual void SetStopOnRedirect(bool stop_on_redirect) OVERRIDE;
-  virtual void SetAutomaticallyRetryOn5xx(bool retry) OVERRIDE;
-  virtual void SetMaxRetriesOn5xx(int max_retries) OVERRIDE;
-  virtual int GetMaxRetriesOn5xx() const OVERRIDE;
-  virtual base::TimeDelta GetBackoffDelay() const OVERRIDE;
-  virtual void SetAutomaticallyRetryOnNetworkChanges(int max_retries) OVERRIDE;
+      const CreateDataCallback& create_data_callback) override;
+  virtual void SetStopOnRedirect(bool stop_on_redirect) override;
+  virtual void SetAutomaticallyRetryOn5xx(bool retry) override;
+  virtual void SetMaxRetriesOn5xx(int max_retries) override;
+  virtual int GetMaxRetriesOn5xx() const override;
+  virtual base::TimeDelta GetBackoffDelay() const override;
+  virtual void SetAutomaticallyRetryOnNetworkChanges(int max_retries) override;
   virtual void SaveResponseToFileAtPath(
       const base::FilePath& file_path,
-      scoped_refptr<base::SequencedTaskRunner> file_task_runner) OVERRIDE;
+      scoped_refptr<base::SequencedTaskRunner> file_task_runner) override;
   virtual void SaveResponseToTemporaryFile(
-      scoped_refptr<base::SequencedTaskRunner> file_task_runner) OVERRIDE;
+      scoped_refptr<base::SequencedTaskRunner> file_task_runner) override;
   virtual void SaveResponseWithWriter(
-      scoped_ptr<URLFetcherResponseWriter> response_writer) OVERRIDE;
-  virtual HttpResponseHeaders* GetResponseHeaders() const OVERRIDE;
-  virtual HostPortPair GetSocketAddress() const OVERRIDE;
-  virtual bool WasFetchedViaProxy() const OVERRIDE;
-  virtual void Start() OVERRIDE;
+      scoped_ptr<URLFetcherResponseWriter> response_writer) override;
+  virtual HttpResponseHeaders* GetResponseHeaders() const override;
+  virtual HostPortPair GetSocketAddress() const override;
+  virtual bool WasFetchedViaProxy() const override;
+  virtual void Start() override;
 
   // URL we were created with. Because of how we're using URLFetcher GetURL()
   // always returns an empty URL. Chances are you'll want to use
   // GetOriginalURL() in your tests.
-  virtual const GURL& GetOriginalURL() const OVERRIDE;
-  virtual const GURL& GetURL() const OVERRIDE;
-  virtual const URLRequestStatus& GetStatus() const OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
-  virtual const ResponseCookies& GetCookies() const OVERRIDE;
-  virtual void ReceivedContentWasMalformed() OVERRIDE;
+  virtual const GURL& GetOriginalURL() const override;
+  virtual const GURL& GetURL() const override;
+  virtual const URLRequestStatus& GetStatus() const override;
+  virtual int GetResponseCode() const override;
+  virtual const ResponseCookies& GetCookies() const override;
+  virtual void ReceivedContentWasMalformed() override;
   // Override response access functions to return fake data.
   virtual bool GetResponseAsString(
-      std::string* out_response_string) const OVERRIDE;
+      std::string* out_response_string) const override;
   virtual bool GetResponseAsFilePath(
-      bool take_ownership, base::FilePath* out_response_path) const OVERRIDE;
+      bool take_ownership, base::FilePath* out_response_path) const override;
 
   void GetExtraRequestHeaders(HttpRequestHeaders* headers) const;
 
@@ -247,7 +247,7 @@
       int id,
       const GURL& url,
       URLFetcher::RequestType request_type,
-      URLFetcherDelegate* d) OVERRIDE;
+      URLFetcherDelegate* d) override;
   TestURLFetcher* GetFetcherByID(int id) const;
   void RemoveFetcherFromMap(int id);
   void SetDelegateForTests(TestURLFetcherDelegateForTests* delegate_for_tests);
@@ -299,9 +299,9 @@
 
   // Start the request.  This will call the given delegate asynchronously
   // with the pre-baked response as parameter.
-  virtual void Start() OVERRIDE;
+  virtual void Start() override;
 
-  virtual const GURL& GetURL() const OVERRIDE;
+  virtual const GURL& GetURL() const override;
 
   virtual ~FakeURLFetcher();
 
@@ -407,7 +407,7 @@
       int id,
       const GURL& url,
       URLFetcher::RequestType request_type,
-      URLFetcherDelegate* d) OVERRIDE;
+      URLFetcherDelegate* d) override;
 
   // Sets the fake response for a given URL. The |response_data| may be empty.
   // The |response_code| may be any HttpStatusCode. For instance, HTTP_OK will
@@ -460,7 +460,7 @@
       int id,
       const GURL& url,
       URLFetcher::RequestType request_type,
-      URLFetcherDelegate* d) OVERRIDE;
+      URLFetcherDelegate* d) override;
 };
 
 }  // namespace net
diff --git a/net/url_request/test_url_request_interceptor.cc b/net/url_request/test_url_request_interceptor.cc
index 69235d6..ec60e08 100644
--- a/net/url_request/test_url_request_interceptor.cc
+++ b/net/url_request/test_url_request_interceptor.cc
@@ -30,7 +30,7 @@
                                file_path,
                                worker_task_runner) {}
 
-  virtual int GetResponseCode() const OVERRIDE { return 200; }
+  virtual int GetResponseCode() const override { return 200; }
 
  private:
   virtual ~TestURLRequestJob() {}
@@ -93,7 +93,7 @@
   // When computing matches, this ignores the query parameters of the url.
   virtual net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
+      net::NetworkDelegate* network_delegate) const override {
     DCHECK(network_task_runner_->RunsTasksOnCurrentThread());
     if (request->url().scheme() != scheme_ ||
         request->url().host() != hostname_) {
diff --git a/net/url_request/url_fetcher_core.cc b/net/url_request/url_fetcher_core.cc
index f3e10fd..5ea3921 100644
--- a/net/url_request/url_fetcher_core.cc
+++ b/net/url_request/url_fetcher_core.cc
@@ -14,6 +14,7 @@
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/tracked_objects.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
@@ -548,8 +549,8 @@
       if (!upload_content_.empty()) {
         scoped_ptr<UploadElementReader> reader(new UploadBytesElementReader(
             upload_content_.data(), upload_content_.size()));
-        request_->set_upload(make_scoped_ptr(
-            UploadDataStream::CreateWithReader(reader.Pass(), 0)));
+        request_->set_upload(
+            ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0));
       } else if (!upload_file_path_.empty()) {
         scoped_ptr<UploadElementReader> reader(
             new UploadFileElementReader(upload_file_task_runner_.get(),
@@ -557,8 +558,8 @@
                                         upload_range_offset_,
                                         upload_range_length_,
                                         base::Time()));
-        request_->set_upload(make_scoped_ptr(
-            UploadDataStream::CreateWithReader(reader.Pass(), 0)));
+        request_->set_upload(
+            ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0));
       }
 
       current_upload_bytes_ = -1;
diff --git a/net/url_request/url_fetcher_core.h b/net/url_request/url_fetcher_core.h
index a69eb71..c064a42 100644
--- a/net/url_request/url_fetcher_core.h
+++ b/net/url_request/url_fetcher_core.h
@@ -124,13 +124,13 @@
   // Overridden from URLRequest::Delegate:
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE;
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+                                  bool* defer_redirect) override;
+  virtual void OnResponseStarted(URLRequest* request) override;
   virtual void OnReadCompleted(URLRequest* request,
-                               int bytes_read) OVERRIDE;
+                               int bytes_read) override;
   virtual void OnCertificateRequested(
       URLRequest* request,
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
 
   URLFetcherDelegate* delegate() const { return delegate_; }
   static void CancelAll();
diff --git a/net/url_request/url_fetcher_impl.h b/net/url_request/url_fetcher_impl.h
index bc271b2..e534904 100644
--- a/net/url_request/url_fetcher_impl.h
+++ b/net/url_request/url_fetcher_impl.h
@@ -38,60 +38,60 @@
 
   // URLFetcher implementation:
   virtual void SetUploadData(const std::string& upload_content_type,
-                             const std::string& upload_content) OVERRIDE;
+                             const std::string& upload_content) override;
   virtual void SetUploadFilePath(
       const std::string& upload_content_type,
       const base::FilePath& file_path,
       uint64 range_offset,
       uint64 range_length,
-      scoped_refptr<base::TaskRunner> file_task_runner) OVERRIDE;
+      scoped_refptr<base::TaskRunner> file_task_runner) override;
   virtual void SetChunkedUpload(
-      const std::string& upload_content_type) OVERRIDE;
+      const std::string& upload_content_type) override;
   virtual void AppendChunkToUpload(const std::string& data,
-                                   bool is_last_chunk) OVERRIDE;
-  virtual void SetLoadFlags(int load_flags) OVERRIDE;
-  virtual int GetLoadFlags() const OVERRIDE;
-  virtual void SetReferrer(const std::string& referrer) OVERRIDE;
+                                   bool is_last_chunk) override;
+  virtual void SetLoadFlags(int load_flags) override;
+  virtual int GetLoadFlags() const override;
+  virtual void SetReferrer(const std::string& referrer) override;
   virtual void SetReferrerPolicy(
-      URLRequest::ReferrerPolicy referrer_policy) OVERRIDE;
+      URLRequest::ReferrerPolicy referrer_policy) override;
   virtual void SetExtraRequestHeaders(
-      const std::string& extra_request_headers) OVERRIDE;
-  virtual void AddExtraRequestHeader(const std::string& header_line) OVERRIDE;
+      const std::string& extra_request_headers) override;
+  virtual void AddExtraRequestHeader(const std::string& header_line) override;
   virtual void SetRequestContext(
-      URLRequestContextGetter* request_context_getter) OVERRIDE;
+      URLRequestContextGetter* request_context_getter) override;
   virtual void SetFirstPartyForCookies(
-      const GURL& first_party_for_cookies) OVERRIDE;
+      const GURL& first_party_for_cookies) override;
   virtual void SetURLRequestUserData(
       const void* key,
-      const CreateDataCallback& create_data_callback) OVERRIDE;
-  virtual void SetStopOnRedirect(bool stop_on_redirect) OVERRIDE;
-  virtual void SetAutomaticallyRetryOn5xx(bool retry) OVERRIDE;
-  virtual void SetMaxRetriesOn5xx(int max_retries) OVERRIDE;
-  virtual int GetMaxRetriesOn5xx() const OVERRIDE;
-  virtual base::TimeDelta GetBackoffDelay() const OVERRIDE;
-  virtual void SetAutomaticallyRetryOnNetworkChanges(int max_retries) OVERRIDE;
+      const CreateDataCallback& create_data_callback) override;
+  virtual void SetStopOnRedirect(bool stop_on_redirect) override;
+  virtual void SetAutomaticallyRetryOn5xx(bool retry) override;
+  virtual void SetMaxRetriesOn5xx(int max_retries) override;
+  virtual int GetMaxRetriesOn5xx() const override;
+  virtual base::TimeDelta GetBackoffDelay() const override;
+  virtual void SetAutomaticallyRetryOnNetworkChanges(int max_retries) override;
   virtual void SaveResponseToFileAtPath(
       const base::FilePath& file_path,
-      scoped_refptr<base::SequencedTaskRunner> file_task_runner) OVERRIDE;
+      scoped_refptr<base::SequencedTaskRunner> file_task_runner) override;
   virtual void SaveResponseToTemporaryFile(
-      scoped_refptr<base::SequencedTaskRunner> file_task_runner) OVERRIDE;
+      scoped_refptr<base::SequencedTaskRunner> file_task_runner) override;
   virtual void SaveResponseWithWriter(
-      scoped_ptr<URLFetcherResponseWriter> response_writer) OVERRIDE;
-  virtual HttpResponseHeaders* GetResponseHeaders() const OVERRIDE;
-  virtual HostPortPair GetSocketAddress() const OVERRIDE;
-  virtual bool WasFetchedViaProxy() const OVERRIDE;
-  virtual void Start() OVERRIDE;
-  virtual const GURL& GetOriginalURL() const OVERRIDE;
-  virtual const GURL& GetURL() const OVERRIDE;
-  virtual const URLRequestStatus& GetStatus() const OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
-  virtual const ResponseCookies& GetCookies() const OVERRIDE;
-  virtual void ReceivedContentWasMalformed() OVERRIDE;
+      scoped_ptr<URLFetcherResponseWriter> response_writer) override;
+  virtual HttpResponseHeaders* GetResponseHeaders() const override;
+  virtual HostPortPair GetSocketAddress() const override;
+  virtual bool WasFetchedViaProxy() const override;
+  virtual void Start() override;
+  virtual const GURL& GetOriginalURL() const override;
+  virtual const GURL& GetURL() const override;
+  virtual const URLRequestStatus& GetStatus() const override;
+  virtual int GetResponseCode() const override;
+  virtual const ResponseCookies& GetCookies() const override;
+  virtual void ReceivedContentWasMalformed() override;
   virtual bool GetResponseAsString(
-      std::string* out_response_string) const OVERRIDE;
+      std::string* out_response_string) const override;
   virtual bool GetResponseAsFilePath(
       bool take_ownership,
-      base::FilePath* out_response_path) const OVERRIDE;
+      base::FilePath* out_response_path) const override;
 
   static void CancelAll();
 
diff --git a/net/url_request/url_fetcher_impl_unittest.cc b/net/url_request/url_fetcher_impl_unittest.cc
index 2f1acce..5c97366 100644
--- a/net/url_request/url_fetcher_impl_unittest.cc
+++ b/net/url_request/url_fetcher_impl_unittest.cc
@@ -67,7 +67,7 @@
   }
 
   // TestURLRequestContextGetter:
-  virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
+  virtual TestURLRequestContext* GetURLRequestContext() override {
     return context_;
   }
 
@@ -95,7 +95,7 @@
   // Subclasses that override this should either call this function or
   // CleanupAfterFetchComplete() at the end of their processing, depending on
   // whether they want to check for a non-empty HTTP 200 response or not.
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 
   // Deletes |fetcher| and terminates the message loop.
   void CleanupAfterFetchComplete();
@@ -110,7 +110,7 @@
 
  protected:
   // testing::Test:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     testing::Test::SetUp();
 
     context_.reset(new ThrottlingTestURLRequestContext());
@@ -122,7 +122,7 @@
 #endif
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
 #if defined(USE_NSS) || defined(OS_IOS)
     ShutdownNSSHttpIO();
 #endif
@@ -143,13 +143,13 @@
 class URLFetcherMockDnsTest : public URLFetcherTest {
  public:
   // testing::Test:
-  virtual void SetUp() OVERRIDE;
+  virtual void SetUp() override;
 
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 
  protected:
   GURL test_url_;
@@ -231,10 +231,10 @@
 class URLFetcherPostTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 };
 
 // Version of URLFetcherTest that does a POST of a file using
@@ -249,10 +249,10 @@
   }
 
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 
  private:
   base::FilePath path_;
@@ -264,10 +264,10 @@
 class URLFetcherEmptyPostTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 };
 
 // Version of URLFetcherTest that tests download progress reports.
@@ -279,12 +279,12 @@
   }
 
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchDownloadProgress(const URLFetcher* source,
                                           int64 current,
-                                          int64 total) OVERRIDE;
+                                          int64 total) override;
 
  protected:
   // Download progress returned by the previous callback.
@@ -298,13 +298,13 @@
 class URLFetcherDownloadProgressCancelTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
   virtual void OnURLFetchDownloadProgress(const URLFetcher* source,
                                           int64 current,
-                                          int64 total) OVERRIDE;
+                                          int64 total) override;
  protected:
   bool cancelled_;
 };
@@ -313,12 +313,12 @@
 class URLFetcherUploadProgressTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
   virtual void OnURLFetchUploadProgress(const URLFetcher* source,
                                         int64 current,
-                                        int64 total) OVERRIDE;
+                                        int64 total) override;
  protected:
   int64 previous_progress_;
   std::string chunk_;
@@ -329,14 +329,14 @@
 class URLFetcherHeadersTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 };
 
 // Version of URLFetcherTest that tests SocketAddress.
 class URLFetcherSocketAddressTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
  protected:
   std::string expected_host_;
   uint16 expected_port_;
@@ -349,10 +349,10 @@
   virtual ~URLFetcherStopOnRedirectTest();
 
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 
  protected:
   // The URL we should be redirected to.
@@ -365,10 +365,10 @@
 class URLFetcherProtectTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
  private:
   Time start_time_;
 };
@@ -378,10 +378,10 @@
 class URLFetcherProtectTestPassedThrough : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
  private:
   Time start_time_;
 };
@@ -392,7 +392,7 @@
   URLFetcherBadHTTPSTest();
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 
  private:
   base::FilePath cert_dir_;
@@ -402,10 +402,10 @@
 class URLFetcherCancelTest : public URLFetcherTest {
  public:
   // URLFetcherTest:
-  virtual void CreateFetcher(const GURL& url) OVERRIDE;
+  virtual void CreateFetcher(const GURL& url) override;
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 
   void CancelRequest();
 };
@@ -439,7 +439,7 @@
   }
 
   // TestURLRequestContextGetter:
-  virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE {
+  virtual TestURLRequestContext* GetURLRequestContext() override {
     if (!context_.get()) {
       context_.reset(new CancelTestURLRequestContext());
       DCHECK(context_->throttler_manager());
@@ -487,7 +487,7 @@
 class URLFetcherMultipleAttemptTest : public URLFetcherTest {
  public:
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
  private:
   std::string data_;
 };
@@ -501,7 +501,7 @@
   void CreateFetcherForTempFile(const GURL& url);
 
   // URLFetcherDelegate:
-  virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE;
+  virtual void OnURLFetchComplete(const URLFetcher* source) override;
 
  protected:
   base::FilePath expected_file_;
diff --git a/net/url_request/url_fetcher_response_writer.h b/net/url_request/url_fetcher_response_writer.h
index 428f441..3321f5c 100644
--- a/net/url_request/url_fetcher_response_writer.h
+++ b/net/url_request/url_fetcher_response_writer.h
@@ -65,12 +65,12 @@
   const std::string& data() const { return data_; }
 
   // URLFetcherResponseWriter overrides:
-  virtual int Initialize(const CompletionCallback& callback) OVERRIDE;
+  virtual int Initialize(const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buffer,
                     int num_bytes,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int Finish(const CompletionCallback& callback) OVERRIDE;
-  virtual URLFetcherStringWriter* AsStringWriter() OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int Finish(const CompletionCallback& callback) override;
+  virtual URLFetcherStringWriter* AsStringWriter() override;
 
  private:
   std::string data_;
@@ -91,12 +91,12 @@
   const base::FilePath& file_path() const { return file_path_; }
 
   // URLFetcherResponseWriter overrides:
-  virtual int Initialize(const CompletionCallback& callback) OVERRIDE;
+  virtual int Initialize(const CompletionCallback& callback) override;
   virtual int Write(IOBuffer* buffer,
                     int num_bytes,
-                    const CompletionCallback& callback) OVERRIDE;
-  virtual int Finish(const CompletionCallback& callback) OVERRIDE;
-  virtual URLFetcherFileWriter* AsFileWriter() OVERRIDE;
+                    const CompletionCallback& callback) override;
+  virtual int Finish(const CompletionCallback& callback) override;
+  virtual URLFetcherFileWriter* AsFileWriter() override;
 
   // Drops ownership of the file at |file_path_|.
   // This class will not delete it or write to it again.
diff --git a/net/url_request/url_fetcher_response_writer_unittest.cc b/net/url_request/url_fetcher_response_writer_unittest.cc
index a2e00c8..71cb671 100644
--- a/net/url_request/url_fetcher_response_writer_unittest.cc
+++ b/net/url_request/url_fetcher_response_writer_unittest.cc
@@ -23,7 +23,7 @@
 
 class URLFetcherStringWriterTest : public PlatformTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     writer_.reset(new URLFetcherStringWriter);
     buf_ = new StringIOBuffer(kData);
   }
@@ -54,7 +54,7 @@
 
 class URLFetcherFileWriterTest : public PlatformTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     file_path_ = temp_dir_.path().AppendASCII("test.txt");
     writer_.reset(new URLFetcherFileWriter(
@@ -144,7 +144,7 @@
 
 class URLFetcherFileWriterTemporaryFileTest : public PlatformTest {
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     writer_.reset(new URLFetcherFileWriter(
         base::MessageLoopProxy::current(), base::FilePath()));
     buf_ = new StringIOBuffer(kData);
diff --git a/net/url_request/url_range_request_job.h b/net/url_request/url_range_request_job.h
index 85f394c..190389d 100644
--- a/net/url_request/url_range_request_job.h
+++ b/net/url_request/url_range_request_job.h
@@ -25,7 +25,7 @@
                      NetworkDelegate* delegate);
 
   virtual void SetExtraRequestHeaders(
-      const HttpRequestHeaders& headers) OVERRIDE;
+      const HttpRequestHeaders& headers) override;
 
   const std::vector<HttpByteRange>& ranges() const { return ranges_; }
   int range_parse_result() const { return range_parse_result_; }
diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc
index 311bb20..7ae48e8 100644
--- a/net/url_request/url_request.cc
+++ b/net/url_request/url_request.cc
@@ -18,6 +18,7 @@
 #include "base/synchronization/lock.h"
 #include "base/values.h"
 #include "net/base/auth.h"
+#include "net/base/chunked_upload_data_stream.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
@@ -223,8 +224,8 @@
 void URLRequest::EnableChunkedUpload() {
   DCHECK(!upload_data_stream_ || upload_data_stream_->is_chunked());
   if (!upload_data_stream_) {
-    upload_data_stream_.reset(
-        new UploadDataStream(UploadDataStream::CHUNKED, 0));
+    upload_chunked_data_stream_ = new ChunkedUploadDataStream(0);
+    upload_data_stream_.reset(upload_chunked_data_stream_);
   }
 }
 
@@ -234,7 +235,7 @@
   DCHECK(upload_data_stream_);
   DCHECK(upload_data_stream_->is_chunked());
   DCHECK_GT(bytes_len, 0);
-  upload_data_stream_->AppendChunk(bytes, bytes_len, is_last_chunk);
+  upload_chunked_data_stream_->AppendData(bytes, bytes_len, is_last_chunk);
 }
 
 void URLRequest::set_upload(scoped_ptr<UploadDataStream> upload) {
diff --git a/net/url_request/url_request.h b/net/url_request/url_request.h
index d8df8fe..a0d5789 100644
--- a/net/url_request/url_request.h
+++ b/net/url_request/url_request.h
@@ -48,6 +48,7 @@
 
 namespace net {
 
+class ChunkedUploadDataStream;
 class CookieOptions;
 class HostPortPair;
 class IOBuffer;
@@ -791,6 +792,10 @@
 
   scoped_refptr<URLRequestJob> job_;
   scoped_ptr<UploadDataStream> upload_data_stream_;
+  // TODO(mmenke):  Make whether or not an upload is chunked transparent to the
+  // URLRequest.
+  ChunkedUploadDataStream* upload_chunked_data_stream_;
+
   std::vector<GURL> url_chain_;
   GURL first_party_for_cookies_;
   GURL delegate_redirect_url_;
diff --git a/net/url_request/url_request_about_job.h b/net/url_request/url_request_about_job.h
index 66a888a..d4b4867 100644
--- a/net/url_request/url_request_about_job.h
+++ b/net/url_request/url_request_about_job.h
@@ -18,8 +18,8 @@
   URLRequestAboutJob(URLRequest* request, NetworkDelegate* network_delegate);
 
   // URLRequestJob:
-  virtual void Start() OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+  virtual void Start() override;
+  virtual bool GetMimeType(std::string* mime_type) const override;
 
  private:
   virtual ~URLRequestAboutJob();
diff --git a/net/url_request/url_request_context_builder.cc b/net/url_request/url_request_context_builder.cc
index a7f5a0b..2e2fcc4 100644
--- a/net/url_request/url_request_context_builder.cc
+++ b/net/url_request/url_request_context_builder.cc
@@ -56,68 +56,68 @@
  private:
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE {
+                                 GURL* new_url) override {
     return OK;
   }
 
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
-                                  HttpRequestHeaders* headers) OVERRIDE {
+                                  HttpRequestHeaders* headers) override {
     return OK;
   }
 
   virtual void OnSendHeaders(URLRequest* request,
-                             const HttpRequestHeaders& headers) OVERRIDE {}
+                             const HttpRequestHeaders& headers) override {}
 
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE {
+      GURL* allowed_unsafe_redirect_url) override {
     return OK;
   }
 
   virtual void OnBeforeRedirect(URLRequest* request,
-                                const GURL& new_location) OVERRIDE {}
+                                const GURL& new_location) override {}
 
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {}
+  virtual void OnResponseStarted(URLRequest* request) override {}
 
   virtual void OnRawBytesRead(const URLRequest& request,
-                              int bytes_read) OVERRIDE {}
+                              int bytes_read) override {}
 
-  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE {}
+  virtual void OnCompleted(URLRequest* request, bool started) override {}
 
-  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE {}
+  virtual void OnURLRequestDestroyed(URLRequest* request) override {}
 
   virtual void OnPACScriptError(int line_number,
-                                const base::string16& error) OVERRIDE {}
+                                const base::string16& error) override {}
 
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE {
+      AuthCredentials* credentials) override {
     return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
   }
 
   virtual bool OnCanGetCookies(const URLRequest& request,
-                               const CookieList& cookie_list) OVERRIDE {
+                               const CookieList& cookie_list) override {
     return true;
   }
 
   virtual bool OnCanSetCookie(const URLRequest& request,
                               const std::string& cookie_line,
-                              CookieOptions* options) OVERRIDE {
+                              CookieOptions* options) override {
     return true;
   }
 
   virtual bool OnCanAccessFile(const net::URLRequest& request,
-                               const base::FilePath& path) const OVERRIDE {
+                               const base::FilePath& path) const override {
     return true;
   }
 
-  virtual bool OnCanThrottleRequest(const URLRequest& request) const OVERRIDE {
+  virtual bool OnCanThrottleRequest(const URLRequest& request) const override {
     // Returning true will only enable throttling if there's also a
     // URLRequestThrottlerManager, which there isn't, by default.
     return true;
@@ -125,7 +125,7 @@
 
   virtual int OnBeforeSocketStreamConnect(
       SocketStream* stream,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     return OK;
   }
 
diff --git a/net/url_request/url_request_context_builder_unittest.cc b/net/url_request/url_request_context_builder_unittest.cc
index b5a3da2..f0f4b82 100644
--- a/net/url_request/url_request_context_builder_unittest.cc
+++ b/net/url_request/url_request_context_builder_unittest.cc
@@ -51,7 +51,7 @@
                                 CreateReason reason,
                                 int nonce_count,
                                 const BoundNetLog& net_log,
-                                scoped_ptr<HttpAuthHandler>* handler) OVERRIDE {
+                                scoped_ptr<HttpAuthHandler>* handler) override {
     handler->reset();
     return return_code_;
   }
diff --git a/net/url_request/url_request_context_getter.h b/net/url_request/url_request_context_getter.h
index 1f56f70..aa2d64b 100644
--- a/net/url_request/url_request_context_getter.h
+++ b/net/url_request/url_request_context_getter.h
@@ -62,10 +62,10 @@
       const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner);
 
   // net::URLRequestContextGetter implementation:
-  virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE;
+  virtual net::URLRequestContext* GetURLRequestContext() override;
 
   virtual scoped_refptr<base::SingleThreadTaskRunner>
-      GetNetworkTaskRunner() const OVERRIDE;
+      GetNetworkTaskRunner() const override;
 
 private:
   virtual ~TrivialURLRequestContextGetter();
diff --git a/net/url_request/url_request_data_job.h b/net/url_request/url_request_data_job.h
index f2e38aa..c39ae8d 100644
--- a/net/url_request/url_request_data_job.h
+++ b/net/url_request/url_request_data_job.h
@@ -33,7 +33,7 @@
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
-                      const CompletionCallback& callback) const OVERRIDE;
+                      const CompletionCallback& callback) const override;
 
  private:
   virtual ~URLRequestDataJob();
diff --git a/net/url_request/url_request_error_job.h b/net/url_request/url_request_error_job.h
index 7c162f0..0bb37ec 100644
--- a/net/url_request/url_request_error_job.h
+++ b/net/url_request/url_request_error_job.h
@@ -20,7 +20,7 @@
                      NetworkDelegate* network_delegate,
                      int error);
 
-  virtual void Start() OVERRIDE;
+  virtual void Start() override;
 
  private:
   virtual ~URLRequestErrorJob();
diff --git a/net/url_request/url_request_file_dir_job.h b/net/url_request/url_request_file_dir_job.h
index f897493..b353697 100644
--- a/net/url_request/url_request_file_dir_job.h
+++ b/net/url_request/url_request_file_dir_job.h
@@ -27,18 +27,18 @@
   virtual void StartAsync();
 
   // Overridden from URLRequestJob:
-  virtual void Start() OVERRIDE;
-  virtual void Kill() OVERRIDE;
+  virtual void Start() override;
+  virtual void Kill() override;
   virtual bool ReadRawData(IOBuffer* buf,
                            int buf_size,
-                           int* bytes_read) OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual bool GetCharset(std::string* charset) OVERRIDE;
+                           int* bytes_read) override;
+  virtual bool GetMimeType(std::string* mime_type) const override;
+  virtual bool GetCharset(std::string* charset) override;
 
   // Overridden from DirectoryLister::DirectoryListerDelegate:
   virtual void OnListFile(
-      const DirectoryLister::DirectoryListerData& data) OVERRIDE;
-  virtual void OnListDone(int error) OVERRIDE;
+      const DirectoryLister::DirectoryListerData& data) override;
+  virtual void OnListDone(int error) override;
 
  private:
   virtual ~URLRequestFileDirJob();
diff --git a/net/url_request/url_request_file_job.h b/net/url_request/url_request_file_job.h
index 15c1e4d..3a5aae7 100644
--- a/net/url_request/url_request_file_job.h
+++ b/net/url_request/url_request_file_job.h
@@ -36,17 +36,17 @@
                     const scoped_refptr<base::TaskRunner>& file_task_runner);
 
   // URLRequestJob:
-  virtual void Start() OVERRIDE;
-  virtual void Kill() OVERRIDE;
+  virtual void Start() override;
+  virtual void Kill() override;
   virtual bool ReadRawData(IOBuffer* buf,
                            int buf_size,
-                           int* bytes_read) OVERRIDE;
+                           int* bytes_read) override;
   virtual bool IsRedirectResponse(GURL* location,
-                                  int* http_status_code) OVERRIDE;
-  virtual Filter* SetupFilter() const OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
+                                  int* http_status_code) override;
+  virtual Filter* SetupFilter() const override;
+  virtual bool GetMimeType(std::string* mime_type) const override;
   virtual void SetExtraRequestHeaders(
-      const HttpRequestHeaders& headers) OVERRIDE;
+      const HttpRequestHeaders& headers) override;
 
   // An interface for subclasses who wish to monitor read operations.
   virtual void OnSeekComplete(int64 result);
diff --git a/net/url_request/url_request_file_job_unittest.cc b/net/url_request/url_request_file_job_unittest.cc
index 4f7984c..ba87766 100644
--- a/net/url_request/url_request_file_job_unittest.cc
+++ b/net/url_request/url_request_file_job_unittest.cc
@@ -41,12 +41,12 @@
  protected:
   virtual ~URLRequestFileJobWithCallbacks() {}
 
-  virtual void OnSeekComplete(int64 result) OVERRIDE {
+  virtual void OnSeekComplete(int64 result) override {
     ASSERT_EQ(seek_position_, 0);
     seek_position_ = result;
   }
 
-  virtual void OnReadComplete(IOBuffer* buf, int result) OVERRIDE {
+  virtual void OnReadComplete(IOBuffer* buf, int result) override {
     data_chunks_.push_back(std::string(buf->data(), result));
   }
 
@@ -72,7 +72,7 @@
   virtual URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE {
+      NetworkDelegate* network_delegate) const override {
     URLRequestFileJobWithCallbacks* job = new URLRequestFileJobWithCallbacks(
         request,
         network_delegate,
@@ -82,15 +82,15 @@
     return job;
   }
 
-  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
+  virtual bool IsHandledProtocol(const std::string& scheme) const override {
     return scheme == "file";
   }
 
-  virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
+  virtual bool IsHandledURL(const GURL& url) const override {
     return IsHandledProtocol(url.scheme());
   }
 
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE {
+  virtual bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
@@ -116,7 +116,7 @@
 
 class JobObserverImpl : public CallbacksJobFactory::JobObserver {
  public:
-  virtual void OnJobCreated(URLRequestFileJobWithCallbacks* job) OVERRIDE {
+  virtual void OnJobCreated(URLRequestFileJobWithCallbacks* job) override {
     jobs_.push_back(job);
   }
 
diff --git a/net/url_request/url_request_filter.cc b/net/url_request/url_request_filter.cc
index 842a54f..04d61cc 100644
--- a/net/url_request/url_request_filter.cc
+++ b/net/url_request/url_request_filter.cc
@@ -22,7 +22,7 @@
 
   // URLRequestInterceptor implementation.
   virtual URLRequestJob* MaybeInterceptRequest(
-      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE {
+      URLRequest* request, NetworkDelegate* network_delegate) const override {
     return factory_(request, network_delegate, request->url().scheme());
   }
 
diff --git a/net/url_request/url_request_filter.h b/net/url_request/url_request_filter.h
index 93baedb..3388d92 100644
--- a/net/url_request/url_request_filter.h
+++ b/net/url_request/url_request_filter.h
@@ -69,7 +69,7 @@
   // URLRequestInterceptor implementation:
   virtual URLRequestJob* MaybeInterceptRequest(
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE;
+      NetworkDelegate* network_delegate) const override;
 
  private:
   // scheme,hostname -> URLRequestInterceptor
diff --git a/net/url_request/url_request_filter_unittest.cc b/net/url_request/url_request_filter_unittest.cc
index 0e1f2df..bd2a782 100644
--- a/net/url_request/url_request_filter_unittest.cc
+++ b/net/url_request/url_request_filter_unittest.cc
@@ -43,7 +43,7 @@
   virtual ~TestURLRequestInterceptor() {}
 
   virtual URLRequestJob* MaybeInterceptRequest(
-      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE {
+      URLRequest* request, NetworkDelegate* network_delegate) const override {
     job_c = new URLRequestTestJob(request, network_delegate);
     return job_c;
   }
diff --git a/net/url_request/url_request_ftp_job.h b/net/url_request/url_request_ftp_job.h
index 6c40b65..61d4cff 100644
--- a/net/url_request/url_request_ftp_job.h
+++ b/net/url_request/url_request_ftp_job.h
@@ -37,13 +37,13 @@
   virtual ~URLRequestFtpJob();
 
   // Overridden from URLRequestJob:
-  virtual bool IsSafeRedirect(const GURL& location) OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual void GetResponseInfo(HttpResponseInfo* info) OVERRIDE;
-  virtual HostPortPair GetSocketAddress() const OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
-  virtual void Start() OVERRIDE;
-  virtual void Kill() OVERRIDE;
+  virtual bool IsSafeRedirect(const GURL& location) override;
+  virtual bool GetMimeType(std::string* mime_type) const override;
+  virtual void GetResponseInfo(HttpResponseInfo* info) override;
+  virtual HostPortPair GetSocketAddress() const override;
+  virtual void SetPriority(RequestPriority priority) override;
+  virtual void Start() override;
+  virtual void Kill() override;
 
   RequestPriority priority() const { return priority_; }
 
@@ -62,18 +62,18 @@
   void LogFtpServerType(char server_type);
 
   // Overridden from URLRequestJob:
-  virtual LoadState GetLoadState() const OVERRIDE;
-  virtual bool NeedsAuth() OVERRIDE;
+  virtual LoadState GetLoadState() const override;
+  virtual bool NeedsAuth() override;
   virtual void GetAuthChallengeInfo(
-      scoped_refptr<AuthChallengeInfo>* auth_info) OVERRIDE;
-  virtual void SetAuth(const AuthCredentials& credentials) OVERRIDE;
-  virtual void CancelAuth() OVERRIDE;
+      scoped_refptr<AuthChallengeInfo>* auth_info) override;
+  virtual void SetAuth(const AuthCredentials& credentials) override;
+  virtual void CancelAuth() override;
 
   // TODO(ibrar):  Yet to give another look at this function.
-  virtual UploadProgress GetUploadProgress() const OVERRIDE;
+  virtual UploadProgress GetUploadProgress() const override;
   virtual bool ReadRawData(IOBuffer* buf,
                            int buf_size,
-                           int *bytes_read) OVERRIDE;
+                           int *bytes_read) override;
 
   void HandleAuthNeededResponse();
 
diff --git a/net/url_request/url_request_ftp_job_unittest.cc b/net/url_request/url_request_ftp_job_unittest.cc
index 3ecb97e..629613d 100644
--- a/net/url_request/url_request_ftp_job_unittest.cc
+++ b/net/url_request/url_request_ftp_job_unittest.cc
@@ -67,18 +67,18 @@
     config_.proxy_rules().ParseFromString("ftp=localhost");
   }
 
-  virtual void AddObserver(Observer* observer) OVERRIDE {
+  virtual void AddObserver(Observer* observer) override {
     observer_ = observer;
   }
 
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(Observer* observer) override {
     if (observer_ == observer) {
       observer_ = NULL;
     }
   }
 
   virtual ConfigAvailability GetLatestProxyConfig(
-      ProxyConfig* config) OVERRIDE {
+      ProxyConfig* config) override {
     *config = config_;
     return CONFIG_VALID;
   }
@@ -113,11 +113,11 @@
 
 class MockFtpTransactionFactory : public FtpTransactionFactory {
  public:
-  virtual FtpTransaction* CreateTransaction() OVERRIDE {
+  virtual FtpTransaction* CreateTransaction() override {
     return NULL;
   }
 
-  virtual void Suspend(bool suspend) OVERRIDE {}
+  virtual void Suspend(bool suspend) override {}
 };
 
 // Fixture for priority-related tests. Priority matters when there is
diff --git a/net/url_request/url_request_http_job.cc b/net/url_request/url_request_http_job.cc
index 2ebdd15..fc26e94 100644
--- a/net/url_request/url_request_http_job.cc
+++ b/net/url_request/url_request_http_job.cc
@@ -58,17 +58,17 @@
   virtual ~HttpFilterContext();
 
   // FilterContext implementation.
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual bool GetURL(GURL* gurl) const OVERRIDE;
-  virtual bool GetContentDisposition(std::string* disposition) const OVERRIDE;
-  virtual base::Time GetRequestTime() const OVERRIDE;
-  virtual bool IsCachedContent() const OVERRIDE;
-  virtual bool IsDownload() const OVERRIDE;
-  virtual bool SdchResponseExpected() const OVERRIDE;
-  virtual int64 GetByteReadCount() const OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
-  virtual const URLRequestContext* GetURLRequestContext() const OVERRIDE;
-  virtual void RecordPacketStats(StatisticSelector statistic) const OVERRIDE;
+  virtual bool GetMimeType(std::string* mime_type) const override;
+  virtual bool GetURL(GURL* gurl) const override;
+  virtual bool GetContentDisposition(std::string* disposition) const override;
+  virtual base::Time GetRequestTime() const override;
+  virtual bool IsCachedContent() const override;
+  virtual bool IsDownload() const override;
+  virtual bool SdchResponseExpected() const override;
+  virtual int64 GetByteReadCount() const override;
+  virtual int GetResponseCode() const override;
+  virtual const URLRequestContext* GetURLRequestContext() const override;
+  virtual void RecordPacketStats(StatisticSelector statistic) const override;
 
   // Method to allow us to reset filter context for a response that should have
   // been SDCH encoded when there is an update due to an explicit HTTP header.
diff --git a/net/url_request/url_request_http_job.h b/net/url_request/url_request_http_job.h
index 6f8dccc..4b0cc67 100644
--- a/net/url_request/url_request_http_job.h
+++ b/net/url_request/url_request_http_job.h
@@ -48,9 +48,9 @@
   virtual ~URLRequestHttpJob();
 
   // Overridden from URLRequestJob:
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
-  virtual void Start() OVERRIDE;
-  virtual void Kill() OVERRIDE;
+  virtual void SetPriority(RequestPriority priority) override;
+  virtual void Start() override;
+  virtual void Kill() override;
 
   RequestPriority priority() const {
     return priority_;
@@ -99,44 +99,44 @@
   void RestartTransactionWithAuth(const AuthCredentials& credentials);
 
   // Overridden from URLRequestJob:
-  virtual void SetUpload(UploadDataStream* upload) OVERRIDE;
+  virtual void SetUpload(UploadDataStream* upload) override;
   virtual void SetExtraRequestHeaders(
-      const HttpRequestHeaders& headers) OVERRIDE;
-  virtual LoadState GetLoadState() const OVERRIDE;
-  virtual UploadProgress GetUploadProgress() const OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual bool GetCharset(std::string* charset) OVERRIDE;
-  virtual void GetResponseInfo(HttpResponseInfo* info) OVERRIDE;
+      const HttpRequestHeaders& headers) override;
+  virtual LoadState GetLoadState() const override;
+  virtual UploadProgress GetUploadProgress() const override;
+  virtual bool GetMimeType(std::string* mime_type) const override;
+  virtual bool GetCharset(std::string* charset) override;
+  virtual void GetResponseInfo(HttpResponseInfo* info) override;
   virtual void GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual bool GetResponseCookies(std::vector<std::string>* cookies) OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
-  virtual Filter* SetupFilter() const OVERRIDE;
-  virtual bool CopyFragmentOnRedirect(const GURL& location) const OVERRIDE;
-  virtual bool IsSafeRedirect(const GURL& location) OVERRIDE;
-  virtual bool NeedsAuth() OVERRIDE;
-  virtual void GetAuthChallengeInfo(scoped_refptr<AuthChallengeInfo>*) OVERRIDE;
-  virtual void SetAuth(const AuthCredentials& credentials) OVERRIDE;
-  virtual void CancelAuth() OVERRIDE;
-  virtual void ContinueWithCertificate(X509Certificate* client_cert) OVERRIDE;
-  virtual void ContinueDespiteLastError() OVERRIDE;
-  virtual void ResumeNetworkStart() OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
+  virtual bool GetResponseCookies(std::vector<std::string>* cookies) override;
+  virtual int GetResponseCode() const override;
+  virtual Filter* SetupFilter() const override;
+  virtual bool CopyFragmentOnRedirect(const GURL& location) const override;
+  virtual bool IsSafeRedirect(const GURL& location) override;
+  virtual bool NeedsAuth() override;
+  virtual void GetAuthChallengeInfo(scoped_refptr<AuthChallengeInfo>*) override;
+  virtual void SetAuth(const AuthCredentials& credentials) override;
+  virtual void CancelAuth() override;
+  virtual void ContinueWithCertificate(X509Certificate* client_cert) override;
+  virtual void ContinueDespiteLastError() override;
+  virtual void ResumeNetworkStart() override;
   virtual bool ReadRawData(IOBuffer* buf, int buf_size,
-                           int* bytes_read) OVERRIDE;
-  virtual void StopCaching() OVERRIDE;
+                           int* bytes_read) override;
+  virtual void StopCaching() override;
   virtual bool GetFullRequestHeaders(
-      HttpRequestHeaders* headers) const OVERRIDE;
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
-  virtual void DoneReading() OVERRIDE;
-  virtual void DoneReadingRedirectResponse() OVERRIDE;
+      HttpRequestHeaders* headers) const override;
+  virtual int64 GetTotalReceivedBytes() const override;
+  virtual void DoneReading() override;
+  virtual void DoneReadingRedirectResponse() override;
 
-  virtual HostPortPair GetSocketAddress() const OVERRIDE;
-  virtual void NotifyURLRequestDestroyed() OVERRIDE;
+  virtual HostPortPair GetSocketAddress() const override;
+  virtual void NotifyURLRequestDestroyed() override;
 
   void RecordTimer();
   void ResetTimer();
 
-  virtual void UpdatePacketReadTimes() OVERRIDE;
+  virtual void UpdatePacketReadTimes() override;
   void RecordPacketStats(FilterContext::StatisticSelector statistic) const;
 
   void RecordCompressionHistograms();
diff --git a/net/url_request/url_request_http_job_unittest.cc b/net/url_request/url_request_http_job_unittest.cc
index 5cb84d6..c6848d3 100644
--- a/net/url_request/url_request_http_job_unittest.cc
+++ b/net/url_request/url_request_http_job_unittest.cc
@@ -231,7 +231,7 @@
   // scoped_ptr, so this forwarding method acts as a workaround.
   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
-      bool using_proxy) OVERRIDE {
+      bool using_proxy) override {
     // Discard the arguments since we don't need them anyway.
     return CreateBasicStreamMock();
   }
@@ -256,58 +256,58 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     initialize_stream_was_called_ = true;
     return ERR_IO_PENDING;
   }
 
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE {
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
-                               const CompletionCallback& callback) OVERRIDE {
+                               const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
-  virtual void Close(bool not_reusable) OVERRIDE {}
+  virtual void Close(bool not_reusable) override {}
 
-  virtual bool IsResponseBodyComplete() const OVERRIDE { return false; }
+  virtual bool IsResponseBodyComplete() const override { return false; }
 
-  virtual bool CanFindEndOfResponse() const OVERRIDE { return false; }
+  virtual bool CanFindEndOfResponse() const override { return false; }
 
-  virtual bool IsConnectionReused() const OVERRIDE { return false; }
-  virtual void SetConnectionReused() OVERRIDE {}
+  virtual bool IsConnectionReused() const override { return false; }
+  virtual void SetConnectionReused() override {}
 
-  virtual bool IsConnectionReusable() const OVERRIDE { return false; }
+  virtual bool IsConnectionReusable() const override { return false; }
 
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE { return 0; }
+  virtual int64 GetTotalReceivedBytes() const override { return 0; }
 
   virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const
-      OVERRIDE {
+      override {
     return false;
   }
 
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {}
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override {}
 
   virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      OVERRIDE {}
+      override {}
 
-  virtual bool IsSpdyHttpStream() const OVERRIDE { return false; }
+  virtual bool IsSpdyHttpStream() const override { return false; }
 
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE {}
+  virtual void Drain(HttpNetworkSession* session) override {}
 
-  virtual void SetPriority(RequestPriority priority) OVERRIDE {}
+  virtual void SetPriority(RequestPriority priority) override {}
 
   // Fake implementation of WebSocketHandshakeStreamBase method(s)
-  virtual scoped_ptr<WebSocketStream> Upgrade() OVERRIDE {
+  virtual scoped_ptr<WebSocketStream> Upgrade() override {
     return scoped_ptr<WebSocketStream>();
   }
 
diff --git a/net/url_request/url_request_intercepting_job_factory.h b/net/url_request/url_request_intercepting_job_factory.h
index b18af54..909a25c 100644
--- a/net/url_request/url_request_intercepting_job_factory.h
+++ b/net/url_request/url_request_intercepting_job_factory.h
@@ -41,10 +41,10 @@
   virtual URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE;
-  virtual bool IsHandledURL(const GURL& url) const OVERRIDE;
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+      NetworkDelegate* network_delegate) const override;
+  virtual bool IsHandledProtocol(const std::string& scheme) const override;
+  virtual bool IsHandledURL(const GURL& url) const override;
+  virtual bool IsSafeRedirectTarget(const GURL& location) const override;
 
  private:
   scoped_ptr<URLRequestJobFactory> job_factory_;
diff --git a/net/url_request/url_request_job.h b/net/url_request/url_request_job.h
index 2dcd67a..5b8760f 100644
--- a/net/url_request/url_request_job.h
+++ b/net/url_request/url_request_job.h
@@ -219,7 +219,7 @@
 
   // base::PowerObserver methods:
   // We invoke URLRequestJob::Kill on suspend (crbug.com/4606).
-  virtual void OnSuspend() OVERRIDE;
+  virtual void OnSuspend() override;
 
   // Called after a NetworkDelegate has been informed that the URLRequest
   // will be destroyed. This is used to track that no pending callbacks
diff --git a/net/url_request/url_request_job_factory_impl.h b/net/url_request/url_request_job_factory_impl.h
index 8de514f..94112c1 100644
--- a/net/url_request/url_request_job_factory_impl.h
+++ b/net/url_request/url_request_job_factory_impl.h
@@ -32,10 +32,10 @@
   virtual URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE;
-  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE;
-  virtual bool IsHandledURL(const GURL& url) const OVERRIDE;
-  virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE;
+      NetworkDelegate* network_delegate) const override;
+  virtual bool IsHandledProtocol(const std::string& scheme) const override;
+  virtual bool IsHandledURL(const GURL& url) const override;
+  virtual bool IsSafeRedirectTarget(const GURL& location) const override;
 
  private:
   // For testing only.
diff --git a/net/url_request/url_request_job_factory_impl_unittest.cc b/net/url_request/url_request_job_factory_impl_unittest.cc
index 2c36976..61467f1 100644
--- a/net/url_request/url_request_job_factory_impl_unittest.cc
+++ b/net/url_request/url_request_job_factory_impl_unittest.cc
@@ -26,7 +26,7 @@
         status_(status),
         weak_factory_(this) {}
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     // Start reading asynchronously so that all error reporting and data
     // callbacks happen as they would for network requests.
     base::MessageLoop::current()->PostTask(
@@ -50,7 +50,7 @@
 class DummyProtocolHandler : public URLRequestJobFactory::ProtocolHandler {
  public:
   virtual URLRequestJob* MaybeCreateJob(
-      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE {
+      URLRequest* request, NetworkDelegate* network_delegate) const override {
     return new MockURLRequestJob(
         request,
         network_delegate,
diff --git a/net/url_request/url_request_redirect_job.h b/net/url_request/url_request_redirect_job.h
index 23fc811..54bc3f0 100644
--- a/net/url_request/url_request_redirect_job.h
+++ b/net/url_request/url_request_redirect_job.h
@@ -42,12 +42,12 @@
                         const std::string& redirect_reason);
 
   // URLRequestJob implementation:
-  virtual void GetResponseInfo(HttpResponseInfo* info) OVERRIDE;
+  virtual void GetResponseInfo(HttpResponseInfo* info) override;
   virtual void GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual void Start() OVERRIDE;
-  virtual bool CopyFragmentOnRedirect(const GURL& location) const OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
+  virtual void Start() override;
+  virtual bool CopyFragmentOnRedirect(const GURL& location) const override;
+  virtual int GetResponseCode() const override;
 
  private:
   virtual ~URLRequestRedirectJob();
diff --git a/net/url_request/url_request_simple_job.cc b/net/url_request/url_request_simple_job.cc
index f266e3b..a02da27 100644
--- a/net/url_request/url_request_simple_job.cc
+++ b/net/url_request/url_request_simple_job.cc
@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
+#include "base/profiler/scoped_profile.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
@@ -60,6 +61,11 @@
     return;
 
   if (ranges().size() > 1) {
+    // TODO(vadimt): Remove ScopedProfile below once crbug.com/422489 is fixed.
+    tracked_objects::ScopedProfile tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422489 URLRequestSimpleJob::StartAsync 1"));
+
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED,
                                 ERR_REQUEST_RANGE_NOT_SATISFIABLE));
     return;
@@ -68,11 +74,29 @@
   if (!ranges().empty() && range_parse_result() == OK)
     byte_range_ = ranges().front();
 
-  int result = GetData(&mime_type_, &charset_, &data_,
-                       base::Bind(&URLRequestSimpleJob::OnGetDataCompleted,
-                                  weak_factory_.GetWeakPtr()));
-  if (result != ERR_IO_PENDING)
+  int result;
+  {
+    // TODO(vadimt): Remove ScopedProfile below once crbug.com/422489 is fixed.
+    // Remove the block and assign 'result' in its declaration.
+    tracked_objects::ScopedProfile tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422489 URLRequestSimpleJob::StartAsync 2"));
+
+    result = GetData(&mime_type_,
+                     &charset_,
+                     &data_,
+                     base::Bind(&URLRequestSimpleJob::OnGetDataCompleted,
+                                weak_factory_.GetWeakPtr()));
+  }
+
+  if (result != ERR_IO_PENDING) {
+    // TODO(vadimt): Remove ScopedProfile below once crbug.com/422489 is fixed.
+    tracked_objects::ScopedProfile tracking_profile(
+        FROM_HERE_WITH_EXPLICIT_FUNCTION(
+            "422489 URLRequestSimpleJob::StartAsync 3"));
+
     OnGetDataCompleted(result);
+  }
 }
 
 void URLRequestSimpleJob::OnGetDataCompleted(int result) {
diff --git a/net/url_request/url_request_simple_job.h b/net/url_request/url_request_simple_job.h
index 633a2e7..01bd319 100644
--- a/net/url_request/url_request_simple_job.h
+++ b/net/url_request/url_request_simple_job.h
@@ -20,12 +20,12 @@
  public:
   URLRequestSimpleJob(URLRequest* request, NetworkDelegate* network_delegate);
 
-  virtual void Start() OVERRIDE;
+  virtual void Start() override;
   virtual bool ReadRawData(IOBuffer* buf,
                            int buf_size,
-                           int *bytes_read) OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual bool GetCharset(std::string* charset) OVERRIDE;
+                           int *bytes_read) override;
+  virtual bool GetMimeType(std::string* mime_type) const override;
+  virtual bool GetCharset(std::string* charset) override;
 
  protected:
   virtual ~URLRequestSimpleJob();
diff --git a/net/url_request/url_request_simple_job_unittest.cc b/net/url_request/url_request_simple_job_unittest.cc
index 512833f..b75da80 100644
--- a/net/url_request/url_request_simple_job_unittest.cc
+++ b/net/url_request/url_request_simple_job_unittest.cc
@@ -35,7 +35,7 @@
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
-                      const CompletionCallback& callback) const OVERRIDE {
+                      const CompletionCallback& callback) const override {
     mime_type->assign("text/plain");
     charset->assign("US-ASCII");
     data->assign(kTestData);
@@ -55,7 +55,7 @@
  public:
   virtual URLRequestJob* MaybeCreateJob(
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE {
+      NetworkDelegate* network_delegate) const override {
     return new MockSimpleJob(request, network_delegate);
   }
 };
diff --git a/net/url_request/url_request_test_job.cc b/net/url_request/url_request_test_job.cc
index 422e080..3806e25 100644
--- a/net/url_request/url_request_test_job.cc
+++ b/net/url_request/url_request_test_job.cc
@@ -28,7 +28,7 @@
  public:
   // URLRequestJobFactory::ProtocolHandler implementation:
   virtual URLRequestJob* MaybeCreateJob(
-      URLRequest* request, NetworkDelegate* network_delegate) const OVERRIDE {
+      URLRequest* request, NetworkDelegate* network_delegate) const override {
     return new URLRequestTestJob(request, network_delegate);
   }
 };
diff --git a/net/url_request/url_request_test_job.h b/net/url_request/url_request_test_job.h
index 1a85fb0..f0f26fd 100644
--- a/net/url_request/url_request_test_job.h
+++ b/net/url_request/url_request_test_job.h
@@ -108,19 +108,19 @@
   static URLRequestJobFactory::ProtocolHandler* CreateProtocolHandler();
 
   // Job functions
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
-  virtual void Start() OVERRIDE;
+  virtual void SetPriority(RequestPriority priority) override;
+  virtual void Start() override;
   virtual bool ReadRawData(IOBuffer* buf,
                            int buf_size,
-                           int *bytes_read) OVERRIDE;
-  virtual void Kill() OVERRIDE;
-  virtual bool GetMimeType(std::string* mime_type) const OVERRIDE;
-  virtual void GetResponseInfo(HttpResponseInfo* info) OVERRIDE;
+                           int *bytes_read) override;
+  virtual void Kill() override;
+  virtual bool GetMimeType(std::string* mime_type) const override;
+  virtual void GetResponseInfo(HttpResponseInfo* info) override;
   virtual void GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
+      LoadTimingInfo* load_timing_info) const override;
+  virtual int GetResponseCode() const override;
   virtual bool IsRedirectResponse(GURL* location,
-                                  int* http_status_code) OVERRIDE;
+                                  int* http_status_code) override;
 
  protected:
   // Override to specify whether the next read done from this job will
diff --git a/net/url_request/url_request_test_util.h b/net/url_request/url_request_test_util.h
index cad472e..d301154 100644
--- a/net/url_request/url_request_test_util.h
+++ b/net/url_request/url_request_test_util.h
@@ -108,9 +108,9 @@
       scoped_ptr<TestURLRequestContext> context);
 
   // URLRequestContextGetter implementation.
-  virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE;
+  virtual TestURLRequestContext* GetURLRequestContext() override;
   virtual scoped_refptr<base::SingleThreadTaskRunner>
-      GetNetworkTaskRunner() const OVERRIDE;
+      GetNetworkTaskRunner() const override;
 
  protected:
   virtual ~TestURLRequestContextGetter();
@@ -171,19 +171,19 @@
   // URLRequest::Delegate:
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE;
-  virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer) OVERRIDE;
+                                  bool* defer_redirect) override;
+  virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer) override;
   virtual void OnAuthRequired(URLRequest* request,
-                              AuthChallengeInfo* auth_info) OVERRIDE;
+                              AuthChallengeInfo* auth_info) override;
   // NOTE: |fatal| causes |certificate_errors_are_fatal_| to be set to true.
   // (Unit tests use this as a post-condition.) But for policy, this method
   // consults |allow_certificate_errors_|.
   virtual void OnSSLCertificateError(URLRequest* request,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE;
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+                                     bool fatal) override;
+  virtual void OnResponseStarted(URLRequest* request) override;
   virtual void OnReadCompleted(URLRequest* request,
-                               int bytes_read) OVERRIDE;
+                               int bytes_read) override;
 
  private:
   static const int kBufferSize = 4096;
@@ -286,52 +286,52 @@
   // NetworkDelegate:
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE;
+                                 GURL* new_url) override;
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
-                                  HttpRequestHeaders* headers) OVERRIDE;
+                                  HttpRequestHeaders* headers) override;
   virtual void OnBeforeSendProxyHeaders(
       net::URLRequest* request,
       const net::ProxyInfo& proxy_info,
-      net::HttpRequestHeaders* headers) OVERRIDE;
+      net::HttpRequestHeaders* headers) override;
   virtual void OnSendHeaders(URLRequest* request,
-                             const HttpRequestHeaders& headers) OVERRIDE;
+                             const HttpRequestHeaders& headers) override;
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE;
+      GURL* allowed_unsafe_redirect_url) override;
   virtual void OnBeforeRedirect(URLRequest* request,
-                                const GURL& new_location) OVERRIDE;
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+                                const GURL& new_location) override;
+  virtual void OnResponseStarted(URLRequest* request) override;
   virtual void OnRawBytesRead(const URLRequest& request,
-                              int bytes_read) OVERRIDE;
-  virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE;
-  virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE;
+                              int bytes_read) override;
+  virtual void OnCompleted(URLRequest* request, bool started) override;
+  virtual void OnURLRequestDestroyed(URLRequest* request) override;
   virtual void OnPACScriptError(int line_number,
-                                const base::string16& error) OVERRIDE;
+                                const base::string16& error) override;
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE;
+      AuthCredentials* credentials) override;
   virtual bool OnCanGetCookies(const URLRequest& request,
-                               const CookieList& cookie_list) OVERRIDE;
+                               const CookieList& cookie_list) override;
   virtual bool OnCanSetCookie(const URLRequest& request,
                               const std::string& cookie_line,
-                              CookieOptions* options) OVERRIDE;
+                              CookieOptions* options) override;
   virtual bool OnCanAccessFile(const URLRequest& request,
-                               const base::FilePath& path) const OVERRIDE;
+                               const base::FilePath& path) const override;
   virtual bool OnCanThrottleRequest(
-      const URLRequest& request) const OVERRIDE;
+      const URLRequest& request) const override;
   virtual int OnBeforeSocketStreamConnect(
       SocketStream* stream,
-      const CompletionCallback& callback) OVERRIDE;
+      const CompletionCallback& callback) override;
   virtual bool OnCancelURLRequestWithPolicyViolatingReferrerHeader(
       const URLRequest& request,
       const GURL& target_url,
-      const GURL& referrer_url) const OVERRIDE;
+      const GURL& referrer_url) const override;
 
   void InitRequestStatesIfNew(int request_id);
 
@@ -408,7 +408,7 @@
 
   virtual URLRequestJob* MaybeCreateJob(
       URLRequest* request,
-      NetworkDelegate* network_delegate) const OVERRIDE;
+      NetworkDelegate* network_delegate) const override;
   void set_main_intercept_job(URLRequestJob* job);
 
  private:
diff --git a/net/url_request/url_request_throttler_entry.cc b/net/url_request/url_request_throttler_entry.cc
index 5d0c43a..b812de8 100644
--- a/net/url_request/url_request_throttler_entry.cc
+++ b/net/url_request/url_request_throttler_entry.cc
@@ -54,12 +54,13 @@
 // Returns NetLog parameters when a request is rejected by throttling.
 base::Value* NetLogRejectedRequestCallback(const std::string* url_id,
                                            int num_failures,
-                                           int release_after_ms,
+                                           const base::TimeDelta& release_after,
                                            NetLog::LogLevel /* log_level */) {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("url", *url_id);
   dict->SetInteger("num_failures", num_failures);
-  dict->SetInteger("release_after_ms", release_after_ms);
+  dict->SetInteger("release_after_ms",
+                   static_cast<int>(release_after.InMilliseconds()));
   return dict;
 }
 
@@ -156,15 +157,12 @@
   if (!is_backoff_disabled_ && !ExplicitUserRequest(request.load_flags()) &&
       (!network_delegate || network_delegate->CanThrottleRequest(request)) &&
       GetBackoffEntry()->ShouldRejectRequest()) {
-    int num_failures = GetBackoffEntry()->failure_count();
-    int release_after_ms =
-        GetBackoffEntry()->GetTimeUntilRelease().InMilliseconds();
-
     net_log_.AddEvent(
         NetLog::TYPE_THROTTLING_REJECTED_REQUEST,
         base::Bind(&NetLogRejectedRequestCallback,
-                   &url_id_, num_failures, release_after_ms));
-
+                   &url_id_,
+                   GetBackoffEntry()->failure_count(),
+                   GetBackoffEntry()->GetTimeUntilRelease()));
     reject_request = true;
   }
 
diff --git a/net/url_request/url_request_throttler_entry.h b/net/url_request/url_request_throttler_entry.h
index a7a0524..489eecb 100644
--- a/net/url_request/url_request_throttler_entry.h
+++ b/net/url_request/url_request_throttler_entry.h
@@ -95,14 +95,14 @@
   // Implementation of URLRequestThrottlerEntryInterface.
   virtual bool ShouldRejectRequest(
       const URLRequest& request,
-      NetworkDelegate* network_delegate) const OVERRIDE;
+      NetworkDelegate* network_delegate) const override;
   virtual int64 ReserveSendingTimeForNextRequest(
-      const base::TimeTicks& earliest_time) OVERRIDE;
-  virtual base::TimeTicks GetExponentialBackoffReleaseTime() const OVERRIDE;
+      const base::TimeTicks& earliest_time) override;
+  virtual base::TimeTicks GetExponentialBackoffReleaseTime() const override;
   virtual void UpdateWithResponse(
       const std::string& host,
-      const URLRequestThrottlerHeaderInterface* response) OVERRIDE;
-  virtual void ReceivedContentWasMalformed(int response_code) OVERRIDE;
+      const URLRequestThrottlerHeaderInterface* response) override;
+  virtual void ReceivedContentWasMalformed(int response_code) override;
 
  protected:
   virtual ~URLRequestThrottlerEntry();
diff --git a/net/url_request/url_request_throttler_header_adapter.h b/net/url_request/url_request_throttler_header_adapter.h
index 17a13a1..ddf7865 100644
--- a/net/url_request/url_request_throttler_header_adapter.h
+++ b/net/url_request/url_request_throttler_header_adapter.h
@@ -23,8 +23,8 @@
   virtual ~URLRequestThrottlerHeaderAdapter();
 
   // Implementation of URLRequestThrottlerHeaderInterface
-  virtual std::string GetNormalizedValue(const std::string& key) const OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
+  virtual std::string GetNormalizedValue(const std::string& key) const override;
+  virtual int GetResponseCode() const override;
 
  private:
   const scoped_refptr<HttpResponseHeaders> response_header_;
diff --git a/net/url_request/url_request_throttler_manager.h b/net/url_request/url_request_throttler_manager.h
index 31d28ef..10c6561 100644
--- a/net/url_request/url_request_throttler_manager.h
+++ b/net/url_request/url_request_throttler_manager.h
@@ -78,11 +78,11 @@
   NetLog* net_log() const;
 
   // IPAddressObserver interface.
-  virtual void OnIPAddressChanged() OVERRIDE;
+  virtual void OnIPAddressChanged() override;
 
   // ConnectionTypeObserver interface.
   virtual void OnConnectionTypeChanged(
-      NetworkChangeNotifier::ConnectionType type) OVERRIDE;
+      NetworkChangeNotifier::ConnectionType type) override;
 
   // Method that allows us to transform a URL into an ID that can be used in our
   // map. Resulting IDs will be lowercase and consist of the scheme, host, port
diff --git a/net/url_request/url_request_throttler_simulation_unittest.cc b/net/url_request/url_request_throttler_simulation_unittest.cc
index d806376..2f3abbf 100644
--- a/net/url_request/url_request_throttler_simulation_unittest.cc
+++ b/net/url_request/url_request_throttler_simulation_unittest.cc
@@ -135,11 +135,11 @@
     end_downtime_ = start_time + duration;
   }
 
-  virtual void AdvanceTime(const TimeTicks& absolute_time) OVERRIDE {
+  virtual void AdvanceTime(const TimeTicks& absolute_time) override {
     now_ = absolute_time;
   }
 
-  virtual void PerformAction() OVERRIDE {
+  virtual void PerformAction() override {
     // We are inserted at the end of the actor's list, so all Requester
     // instances have already done their bit.
     if (num_current_tick_queries_ > max_experienced_queries_per_tick_)
@@ -306,15 +306,15 @@
       : URLRequestThrottlerEntry(manager, std::string()),
         mock_backoff_entry_(&backoff_policy_) {}
 
-  virtual const BackoffEntry* GetBackoffEntry() const OVERRIDE {
+  virtual const BackoffEntry* GetBackoffEntry() const override {
     return &mock_backoff_entry_;
   }
 
-  virtual BackoffEntry* GetBackoffEntry() OVERRIDE {
+  virtual BackoffEntry* GetBackoffEntry() override {
     return &mock_backoff_entry_;
   }
 
-  virtual TimeTicks ImplGetTimeNow() const OVERRIDE {
+  virtual TimeTicks ImplGetTimeNow() const override {
     return fake_now_;
   }
 
@@ -414,14 +414,14 @@
     DCHECK(server_);
   }
 
-  virtual void AdvanceTime(const TimeTicks& absolute_time) OVERRIDE {
+  virtual void AdvanceTime(const TimeTicks& absolute_time) override {
     if (time_of_last_success_.is_null())
       time_of_last_success_ = absolute_time;
 
     throttler_entry_->SetFakeNow(absolute_time);
   }
 
-  virtual void PerformAction() OVERRIDE {
+  virtual void PerformAction() override {
     TimeDelta effective_delay = time_between_requests_;
     TimeDelta current_jitter = TimeDelta::FromMilliseconds(
         request_jitter_.InMilliseconds() * base::RandDouble());
diff --git a/net/url_request/url_request_throttler_test_support.h b/net/url_request/url_request_throttler_test_support.h
index fc28068..60a63b2 100644
--- a/net/url_request/url_request_throttler_test_support.h
+++ b/net/url_request/url_request_throttler_test_support.h
@@ -19,7 +19,7 @@
   virtual ~MockBackoffEntry();
 
   // BackoffEntry overrides.
-  virtual base::TimeTicks ImplGetTimeNow() const OVERRIDE;
+  virtual base::TimeTicks ImplGetTimeNow() const override;
 
   void set_fake_now(const base::TimeTicks& now);
 
@@ -45,8 +45,8 @@
   virtual ~MockURLRequestThrottlerHeaderAdapter();
 
   // URLRequestThrottlerHeaderInterface overrides.
-  virtual std::string GetNormalizedValue(const std::string& key) const OVERRIDE;
-  virtual int GetResponseCode() const OVERRIDE;
+  virtual std::string GetNormalizedValue(const std::string& key) const override;
+  virtual int GetResponseCode() const override;
 
  private:
   std::string fake_retry_value_;
diff --git a/net/url_request/url_request_throttler_unittest.cc b/net/url_request/url_request_throttler_unittest.cc
index a3fb410..4188b77 100644
--- a/net/url_request/url_request_throttler_unittest.cc
+++ b/net/url_request/url_request_throttler_unittest.cc
@@ -63,11 +63,11 @@
     backoff_policy_.num_errors_to_ignore = 0;
   }
 
-  virtual const BackoffEntry* GetBackoffEntry() const OVERRIDE {
+  virtual const BackoffEntry* GetBackoffEntry() const override {
     return &mock_backoff_entry_;
   }
 
-  virtual BackoffEntry* GetBackoffEntry() OVERRIDE {
+  virtual BackoffEntry* GetBackoffEntry() override {
     return &mock_backoff_entry_;
   }
 
@@ -85,7 +85,7 @@
   }
 
   // Overridden for tests.
-  virtual TimeTicks ImplGetTimeNow() const OVERRIDE { return fake_time_now_; }
+  virtual TimeTicks ImplGetTimeNow() const override { return fake_time_now_; }
 
   void set_exponential_backoff_release_time(
       const base::TimeTicks& release_time) {
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index dbf858d..0f64a7c 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -31,6 +31,8 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/capturing_net_log.h"
+#include "net/base/chunked_upload_data_stream.h"
+#include "net/base/elements_upload_data_stream.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
@@ -242,10 +244,10 @@
   return it != haystack.end();
 }
 
-UploadDataStream* CreateSimpleUploadData(const char* data) {
+scoped_ptr<UploadDataStream> CreateSimpleUploadData(const char* data) {
   scoped_ptr<UploadElementReader> reader(
       new UploadBytesElementReader(data, strlen(data)));
-  return UploadDataStream::CreateWithReader(reader.Pass(), 0);
+  return ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0);
 }
 
 // Verify that the SSLInfo of a successful SSL connection has valid values.
@@ -367,24 +369,24 @@
   // TestNetworkDelegate implementation.
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE;
+                                 GURL* new_url) override;
 
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
-                                  HttpRequestHeaders* headers) OVERRIDE;
+                                  HttpRequestHeaders* headers) override;
 
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE;
+      GURL* allowed_unsafe_redirect_url) override;
 
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE;
+      AuthCredentials* credentials) override;
 
   // Resets the callbacks and |stage_blocked_for_callback_|.
   void Reset();
@@ -1103,7 +1105,7 @@
   RestartTestJob(URLRequest* request, NetworkDelegate* network_delegate)
     : URLRequestTestJob(request, network_delegate, true) {}
  protected:
-  virtual void StartAsync() OVERRIDE {
+  virtual void StartAsync() override {
     this->NotifyRestartRequired();
   }
  private:
@@ -1115,7 +1117,7 @@
   explicit CancelTestJob(URLRequest* request, NetworkDelegate* network_delegate)
     : URLRequestTestJob(request, network_delegate, true) {}
  protected:
-  virtual void StartAsync() OVERRIDE {
+  virtual void StartAsync() override {
     request_->Cancel();
   }
  private:
@@ -1129,7 +1131,7 @@
       : URLRequestTestJob(request, network_delegate, true) {
   }
  protected:
-  virtual void StartAsync() OVERRIDE {
+  virtual void StartAsync() override {
     request_->Cancel();
     this->NotifyRestartRequired();
   }
@@ -1160,7 +1162,7 @@
 
   virtual URLRequestJob* MaybeIntercept(
       URLRequest* request,
-      NetworkDelegate* network_delegate) OVERRIDE {
+      NetworkDelegate* network_delegate) override {
     if (restart_main_request_) {
       restart_main_request_ = false;
       did_restart_main_ = true;
@@ -1198,7 +1200,7 @@
   virtual URLRequestJob* MaybeInterceptRedirect(
       URLRequest* request,
       NetworkDelegate* network_delegate,
-      const GURL& location) OVERRIDE {
+      const GURL& location) override {
     if (cancel_redirect_request_) {
       cancel_redirect_request_ = false;
       did_cancel_redirect_ = true;
@@ -1216,7 +1218,7 @@
   }
 
   virtual URLRequestJob* MaybeInterceptResponse(
-      URLRequest* request, NetworkDelegate* network_delegate) OVERRIDE {
+      URLRequest* request, NetworkDelegate* network_delegate) override {
     if (cancel_final_request_) {
       cancel_final_request_ = false;
       did_cancel_final_ = true;
@@ -2402,7 +2404,7 @@
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE;
+      GURL* allowed_unsafe_redirect_url) override;
 
  private:
   std::string fixed_date_;
@@ -2556,7 +2558,7 @@
         redirect_url, DEFAULT_PRIORITY, &d, NULL));
     req->set_method(request_method);
     if (include_data) {
-      req->set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+      req->set_upload(CreateSimpleUploadData(kData));
       HttpRequestHeaders headers;
       headers.SetHeader(HttpRequestHeaders::kContentLength,
                         base::UintToString(arraysize(kData) - 1));
@@ -2602,7 +2604,7 @@
           test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d, NULL));
       r->set_method(method.c_str());
 
-      r->set_upload(make_scoped_ptr(CreateSimpleUploadData(uploadBytes)));
+      r->set_upload(CreateSimpleUploadData(uploadBytes));
 
       r->Start();
       EXPECT_TRUE(r->is_pending());
@@ -3015,7 +3017,7 @@
     scoped_ptr<URLRequest> r(context.CreateRequest(
         original_url, DEFAULT_PRIORITY, &d, NULL));
     r->set_method("POST");
-    r->set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+    r->set_upload(CreateSimpleUploadData(kData));
     HttpRequestHeaders headers;
     headers.SetHeader(HttpRequestHeaders::kContentLength,
                       base::UintToString(arraysize(kData) - 1));
@@ -3994,14 +3996,14 @@
   // NetworkDelegate implementation.
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
-                                 GURL* new_url) OVERRIDE {
+                                 GURL* new_url) override {
     TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
     return RunCallbackAsynchronously(request, callback);
   }
 
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
-                                  HttpRequestHeaders* headers) OVERRIDE {
+                                  HttpRequestHeaders* headers) override {
     TestNetworkDelegate::OnBeforeSendHeaders(request, callback, headers);
     return RunCallbackAsynchronously(request, callback);
   }
@@ -4011,7 +4013,7 @@
       const CompletionCallback& callback,
       const HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers,
-      GURL* allowed_unsafe_redirect_url) OVERRIDE {
+      GURL* allowed_unsafe_redirect_url) override {
     TestNetworkDelegate::OnHeadersReceived(request,
                                            callback,
                                            original_response_headers,
@@ -4024,7 +4026,7 @@
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
-      AuthCredentials* credentials) OVERRIDE {
+      AuthCredentials* credentials) override {
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_WAITING_FOR_DELEGATE,
@@ -4086,7 +4088,7 @@
   // URLRequest::Delegate implementation:
   void virtual OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     *defer_redirect = true;
     AsyncDelegateLogger::Run(
         request,
@@ -4098,7 +4100,7 @@
             base::Unretained(this), request, redirect_info));
   }
 
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE {
+  virtual void OnResponseStarted(URLRequest* request) override {
     AsyncDelegateLogger::Run(
       request,
       LOAD_STATE_WAITING_FOR_DELEGATE,
@@ -4110,7 +4112,7 @@
   }
 
   virtual void OnReadCompleted(URLRequest* request,
-                               int bytes_read) OVERRIDE {
+                               int bytes_read) override {
     AsyncDelegateLogger::Run(
         request,
         LOAD_STATE_IDLE,
@@ -4578,7 +4580,7 @@
 class RedirectWithAdditionalHeadersDelegate : public TestDelegate {
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
     request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false);
   }
@@ -4615,7 +4617,7 @@
 class RedirectWithHeaderRemovalDelegate : public TestDelegate {
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
     request->RemoveRequestHeaderByName(kExtraHeaderToRemove);
   }
@@ -4828,8 +4830,8 @@
                                     0,
                                     kuint64max,
                                     base::Time()));
-    r->set_upload(make_scoped_ptr(
-        new UploadDataStream(element_readers.Pass(), 0)));
+    r->set_upload(make_scoped_ptr<UploadDataStream>(
+        new ElementsUploadDataStream(element_readers.Pass(), 0)));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
@@ -4871,8 +4873,8 @@
         0,
         kuint64max,
         base::Time()));
-    r->set_upload(make_scoped_ptr(
-        new UploadDataStream(element_readers.Pass(), 0)));
+    r->set_upload(make_scoped_ptr<UploadDataStream>(
+        new ElementsUploadDataStream(element_readers.Pass(), 0)));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
@@ -5949,7 +5951,7 @@
       test_server_.GetURL("files/redirect-to-echoall"), DEFAULT_PRIORITY, &d,
       NULL));
   req->set_method("POST");
-  req->set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  req->set_upload(CreateSimpleUploadData(kData));
 
   // Set headers (some of which are specific to the POST).
   HttpRequestHeaders headers;
@@ -6136,7 +6138,7 @@
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
       test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d, NULL));
   req->set_method("POST");
-  req->set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  req->set_upload(CreateSimpleUploadData(kData));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::UintToString(arraysize(kData) - 1));
@@ -6161,7 +6163,7 @@
   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
       test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d, NULL));
   req->set_method("POST");
-  req->set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  req->set_upload(CreateSimpleUploadData(kData));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::UintToString(arraysize(kData) - 1));
@@ -6720,7 +6722,7 @@
                                   test_server.host_port_pair().port())),
       DEFAULT_PRIORITY, &d, NULL));
   req->set_method("POST");
-  req->set_upload(make_scoped_ptr(CreateSimpleUploadData(kData)));
+  req->set_upload(CreateSimpleUploadData(kData));
 
   req->Start();
   base::RunLoop().Run();
@@ -6811,7 +6813,7 @@
   }
   virtual void OnCertificateRequested(
       URLRequest* request,
-      SSLCertRequestInfo* cert_request_info) OVERRIDE {
+      SSLCertRequestInfo* cert_request_info) override {
     on_certificate_requested_count_++;
     base::MessageLoop::current()->Quit();
   }
@@ -6934,6 +6936,28 @@
   }
 }
 
+// AssertTwoDistinctSessionsInserted checks that |session_info|, which must be
+// the result of fetching "ssl-session-cache" from the test server, indicates
+// that exactly two different sessions were inserted, with no lookups etc.
+static void AssertTwoDistinctSessionsInserted(const string& session_info) {
+  std::vector<std::string> lines;
+  base::SplitString(session_info, '\n', &lines);
+  ASSERT_EQ(3u, lines.size()) << session_info;
+
+  std::string session_id;
+  for (size_t i = 0; i < 2; i++) {
+    std::vector<std::string> parts;
+    base::SplitString(lines[i], '\t', &parts);
+    ASSERT_EQ(2u, parts.size());
+    EXPECT_EQ("insert", parts[0]);
+    if (i == 0) {
+      session_id = parts[1];
+    } else {
+      EXPECT_NE(session_id, parts[1]);
+    }
+  }
+}
+
 TEST_F(HTTPSRequestTest, SSLSessionCacheShardTest) {
   // Test that sessions aren't resumed when the value of ssl_session_cache_shard
   // differs.
@@ -6997,22 +7021,7 @@
     // three lines.
 
     EXPECT_EQ(1, d.response_started_count());
-    std::vector<std::string> lines;
-    base::SplitString(d.data_received(), '\n', &lines);
-    ASSERT_EQ(3u, lines.size());
-
-    std::string session_id;
-    for (size_t i = 0; i < 2; i++) {
-      std::vector<std::string> parts;
-      base::SplitString(lines[i], '\t', &parts);
-      ASSERT_EQ(2u, parts.size());
-      EXPECT_EQ("insert", parts[0]);
-      if (i == 0) {
-        session_id = parts[1];
-      } else {
-        EXPECT_NE(session_id, parts[1]);
-      }
-    }
+    AssertTwoDistinctSessionsInserted(d.data_received());
   }
 }
 
@@ -7067,17 +7076,70 @@
 
 #endif  // OS_WIN
 
+class TestSSLConfigService : public SSLConfigService {
+ public:
+  TestSSLConfigService(bool ev_enabled,
+                       bool online_rev_checking,
+                       bool rev_checking_required_local_anchors)
+      : ev_enabled_(ev_enabled),
+        online_rev_checking_(online_rev_checking),
+        rev_checking_required_local_anchors_(
+            rev_checking_required_local_anchors),
+        fallback_min_version_(0) {}
+
+  void set_fallback_min_version(uint16 version) {
+    fallback_min_version_ = version;
+  }
+
+  // SSLConfigService:
+  virtual void GetSSLConfig(SSLConfig* config) override {
+    *config = SSLConfig();
+    config->rev_checking_enabled = online_rev_checking_;
+    config->verify_ev_cert = ev_enabled_;
+    config->rev_checking_required_local_anchors =
+        rev_checking_required_local_anchors_;
+    if (fallback_min_version_) {
+      config->version_fallback_min = fallback_min_version_;
+    }
+  }
+
+ protected:
+  virtual ~TestSSLConfigService() {}
+
+ private:
+  const bool ev_enabled_;
+  const bool online_rev_checking_;
+  const bool rev_checking_required_local_anchors_;
+  uint16 fallback_min_version_;
+};
+
+class FallbackTestURLRequestContext : public TestURLRequestContext {
+ public:
+  explicit FallbackTestURLRequestContext(bool delay_initialization)
+      : TestURLRequestContext(delay_initialization) {}
+
+  void set_fallback_min_version(uint16 version) {
+    TestSSLConfigService *ssl_config_service =
+        new TestSSLConfigService(true /* check for EV */,
+                                 false /* online revocation checking */,
+                                 false /* require rev. checking for local
+                                          anchors */);
+    ssl_config_service->set_fallback_min_version(version);
+    set_ssl_config_service(ssl_config_service);
+  }
+};
+
 class HTTPSFallbackTest : public testing::Test {
  public:
-  HTTPSFallbackTest() : context_(true) {
-    context_.Init();
-    delegate_.set_allow_certificate_errors(true);
-  }
+  HTTPSFallbackTest() : context_(true) {}
   virtual ~HTTPSFallbackTest() {}
 
  protected:
   void DoFallbackTest(const SpawnedTestServer::SSLOptions& ssl_options) {
     DCHECK(!request_);
+    context_.Init();
+    delegate_.set_allow_certificate_errors(true);
+
     SpawnedTestServer test_server(
         SpawnedTestServer::TYPE_HTTPS,
         ssl_options,
@@ -7091,6 +7153,10 @@
     base::RunLoop().Run();
   }
 
+  void set_fallback_min_version(uint16 version) {
+    context_.set_fallback_min_version(version);
+  }
+
   void ExpectConnection(int version) {
     EXPECT_EQ(1, delegate_.response_started_count());
     EXPECT_NE(0, delegate_.bytes_received());
@@ -7109,7 +7175,7 @@
 
  private:
   TestDelegate delegate_;
-  TestURLRequestContext context_;
+  FallbackTestURLRequestContext context_;
   scoped_ptr<URLRequest> request_;
 };
 
@@ -7185,7 +7251,7 @@
   ExpectFailure(ERR_CONNECTION_CLOSED);
 }
 
-// Tests that the SSLv3 fallback triggers on alert.
+// Tests that the SSLv3 fallback doesn't happen by default.
 TEST_F(HTTPSFallbackTest, SSLv3Fallback) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_OK);
@@ -7193,10 +7259,23 @@
       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_ALL;
 
   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
+  ExpectFailure(ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION);
+}
+
+// Tests that the SSLv3 fallback works when explicitly enabled.
+TEST_F(HTTPSFallbackTest, SSLv3FallbackEnabled) {
+  SpawnedTestServer::SSLOptions ssl_options(
+      SpawnedTestServer::SSLOptions::CERT_OK);
+  ssl_options.tls_intolerant =
+      SpawnedTestServer::SSLOptions::TLS_INTOLERANT_ALL;
+  set_fallback_min_version(SSL_PROTOCOL_VERSION_SSL3);
+
+  ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
   ExpectConnection(SSL_CONNECTION_VERSION_SSL3);
 }
 
-// Tests that the SSLv3 fallback triggers on closed connections.
+// Tests that the SSLv3 fallback triggers on closed connections when explicitly
+// enabled.
 TEST_F(HTTPSFallbackTest, SSLv3FallbackClosed) {
   SpawnedTestServer::SSLOptions ssl_options(
       SpawnedTestServer::SSLOptions::CERT_OK);
@@ -7204,11 +7283,81 @@
       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_ALL;
   ssl_options.tls_intolerance_type =
       SpawnedTestServer::SSLOptions::TLS_INTOLERANCE_CLOSE;
+  set_fallback_min_version(SSL_PROTOCOL_VERSION_SSL3);
 
   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
   ExpectConnection(SSL_CONNECTION_VERSION_SSL3);
 }
 
+// Test that SSLv3 fallback probe connections don't cause sessions to be cached.
+TEST_F(HTTPSRequestTest, SSLv3FallbackNoCache) {
+  SpawnedTestServer::SSLOptions ssl_options(
+      SpawnedTestServer::SSLOptions::CERT_OK);
+  ssl_options.tls_intolerant =
+      SpawnedTestServer::SSLOptions::TLS_INTOLERANT_ALL;
+  ssl_options.tls_intolerance_type =
+      SpawnedTestServer::SSLOptions::TLS_INTOLERANCE_CLOSE;
+  ssl_options.record_resume = true;
+
+  SpawnedTestServer test_server(
+      SpawnedTestServer::TYPE_HTTPS,
+      ssl_options,
+      base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
+  ASSERT_TRUE(test_server.Start());
+
+  SSLClientSocket::ClearSessionCache();
+
+  // Make a connection that does a probe fallback to SSLv3 but fails because
+  // SSLv3 fallback is disabled. We don't wish a session for this connection to
+  // be inserted locally.
+  {
+    TestDelegate delegate;
+    FallbackTestURLRequestContext context(true);
+
+    context.Init();
+    scoped_ptr<URLRequest> request(context.CreateRequest(
+        test_server.GetURL(std::string()), DEFAULT_PRIORITY, &delegate, NULL));
+    request->Start();
+
+    base::RunLoop().Run();
+
+    EXPECT_EQ(1, delegate.response_started_count());
+    EXPECT_FALSE(request->status().is_success());
+    EXPECT_EQ(URLRequestStatus::FAILED, request->status().status());
+    EXPECT_EQ(ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION,
+              request->status().error());
+  }
+
+  // Now allow SSLv3 connections and request the session cache log.
+  {
+    TestDelegate delegate;
+    FallbackTestURLRequestContext context(true);
+    context.set_fallback_min_version(SSL_PROTOCOL_VERSION_SSL3);
+
+    context.Init();
+    scoped_ptr<URLRequest> request(
+        context.CreateRequest(test_server.GetURL("ssl-session-cache"),
+                               DEFAULT_PRIORITY,
+                               &delegate,
+                               NULL));
+    request->Start();
+
+    base::RunLoop().Run();
+
+    EXPECT_EQ(1, delegate.response_started_count());
+    EXPECT_NE(0, delegate.bytes_received());
+    EXPECT_EQ(SSL_CONNECTION_VERSION_SSL3, SSLConnectionStatusToVersion(
+        request->ssl_info().connection_status));
+    EXPECT_TRUE(request->ssl_info().connection_status &
+                SSL_CONNECTION_VERSION_FALLBACK);
+
+    std::vector<std::string> lines;
+    // If no sessions were cached then the server should have seen two sessions
+    // inserted with no lookups.
+    AssertTwoDistinctSessionsInserted(delegate.data_received());
+  }
+}
+
 // This test is disabled on Android because the remote test server doesn't cause
 // a TCP reset.
 #if !defined(OS_ANDROID)
@@ -7301,53 +7450,10 @@
     //   insert xyz
 
     EXPECT_EQ(1, d.response_started_count());
-    std::vector<std::string> lines;
-    base::SplitString(d.data_received(), '\n', &lines);
-    ASSERT_EQ(3u, lines.size()) << d.data_received();
-
-    std::string session_id;
-    for (size_t i = 0; i < 2; i++) {
-      std::vector<std::string> parts;
-      base::SplitString(lines[i], '\t', &parts);
-      ASSERT_EQ(2u, parts.size());
-      EXPECT_EQ("insert", parts[0]);
-      if (i == 0) {
-        session_id = parts[1];
-      } else {
-        EXPECT_NE(session_id, parts[1]);
-      }
-    }
+    AssertTwoDistinctSessionsInserted(d.data_received());
   }
 }
 
-class TestSSLConfigService : public SSLConfigService {
- public:
-  TestSSLConfigService(bool ev_enabled,
-                       bool online_rev_checking,
-                       bool rev_checking_required_local_anchors)
-      : ev_enabled_(ev_enabled),
-        online_rev_checking_(online_rev_checking),
-        rev_checking_required_local_anchors_(
-            rev_checking_required_local_anchors) {}
-
-  // SSLConfigService:
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {
-    *config = SSLConfig();
-    config->rev_checking_enabled = online_rev_checking_;
-    config->verify_ev_cert = ev_enabled_;
-    config->rev_checking_required_local_anchors =
-        rev_checking_required_local_anchors_;
-  }
-
- protected:
-  virtual ~TestSSLConfigService() {}
-
- private:
-  const bool ev_enabled_;
-  const bool online_rev_checking_;
-  const bool rev_checking_required_local_anchors_;
-};
-
 // This the fingerprint of the "Testing CA" certificate used by the testserver.
 // See net/data/ssl/certificates/ocsp-test-root.pem.
 static const SHA1HashValue kOCSPTestCertFingerprint =
@@ -7377,7 +7483,7 @@
                                    kOCSPTestCertPolicy)) {
   }
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     SetupContext(&context_);
     context_.Init();
 
@@ -7558,7 +7664,7 @@
 
 class HTTPSHardFailTest : public HTTPSOCSPTest {
  protected:
-  virtual void SetupContext(URLRequestContext* context) OVERRIDE {
+  virtual void SetupContext(URLRequestContext* context) override {
     context->set_ssl_config_service(
         new TestSSLConfigService(false /* check for EV */,
                                  false /* online revocation checking */,
@@ -7596,7 +7702,7 @@
 
 class HTTPSEVCRLSetTest : public HTTPSOCSPTest {
  protected:
-  virtual void SetupContext(URLRequestContext* context) OVERRIDE {
+  virtual void SetupContext(URLRequestContext* context) override {
     context->set_ssl_config_service(
         new TestSSLConfigService(true /* check for EV */,
                                  false /* online revocation checking */,
@@ -7781,7 +7887,7 @@
 
 class HTTPSCRLSetTest : public HTTPSOCSPTest {
  protected:
-  virtual void SetupContext(URLRequestContext* context) OVERRIDE {
+  virtual void SetupContext(URLRequestContext* context) override {
     context->set_ssl_config_service(
         new TestSSLConfigService(false /* check for EV */,
                                  false /* online revocation checking */,
diff --git a/net/websockets/websocket_basic_handshake_stream.h b/net/websockets/websocket_basic_handshake_stream.h
index 51f0c4d..cc8f5bf 100644
--- a/net/websockets/websocket_basic_handshake_stream.h
+++ b/net/websockets/websocket_basic_handshake_stream.h
@@ -42,35 +42,35 @@
   virtual int InitializeStream(const HttpRequestInfo* request_info,
                                RequestPriority priority,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) OVERRIDE;
+                               const CompletionCallback& callback) override;
   virtual int SendRequest(const HttpRequestHeaders& request_headers,
                           HttpResponseInfo* response,
-                          const CompletionCallback& callback) OVERRIDE;
-  virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
+  virtual int ReadResponseHeaders(const CompletionCallback& callback) override;
   virtual int ReadResponseBody(IOBuffer* buf,
                                int buf_len,
-                               const CompletionCallback& callback) OVERRIDE;
-  virtual void Close(bool not_reusable) OVERRIDE;
-  virtual bool IsResponseBodyComplete() const OVERRIDE;
-  virtual bool CanFindEndOfResponse() const OVERRIDE;
-  virtual bool IsConnectionReused() const OVERRIDE;
-  virtual void SetConnectionReused() OVERRIDE;
-  virtual bool IsConnectionReusable() const OVERRIDE;
-  virtual int64 GetTotalReceivedBytes() const OVERRIDE;
+                               const CompletionCallback& callback) override;
+  virtual void Close(bool not_reusable) override;
+  virtual bool IsResponseBodyComplete() const override;
+  virtual bool CanFindEndOfResponse() const override;
+  virtual bool IsConnectionReused() const override;
+  virtual void SetConnectionReused() override;
+  virtual bool IsConnectionReusable() const override;
+  virtual int64 GetTotalReceivedBytes() const override;
   virtual bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const
-      OVERRIDE;
-  virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
+      override;
+  virtual void GetSSLInfo(SSLInfo* ssl_info) override;
   virtual void GetSSLCertRequestInfo(
-      SSLCertRequestInfo* cert_request_info) OVERRIDE;
-  virtual bool IsSpdyHttpStream() const OVERRIDE;
-  virtual void Drain(HttpNetworkSession* session) OVERRIDE;
-  virtual void SetPriority(RequestPriority priority) OVERRIDE;
+      SSLCertRequestInfo* cert_request_info) override;
+  virtual bool IsSpdyHttpStream() const override;
+  virtual void Drain(HttpNetworkSession* session) override;
+  virtual void SetPriority(RequestPriority priority) override;
 
   // This is called from the top level once correct handshake response headers
   // have been received. It creates an appropriate subclass of WebSocketStream
   // depending on what extensions were negotiated. This object is unusable after
   // Upgrade() has been called and should be disposed of as soon as possible.
-  virtual scoped_ptr<WebSocketStream> Upgrade() OVERRIDE;
+  virtual scoped_ptr<WebSocketStream> Upgrade() override;
 
   // Set the value used for the next Sec-WebSocket-Key header
   // deterministically. The key is only used once, and then discarded.
diff --git a/net/websockets/websocket_basic_stream.cc b/net/websockets/websocket_basic_stream.cc
index af2444d..2890a9e 100644
--- a/net/websockets/websocket_basic_stream.cc
+++ b/net/websockets/websocket_basic_stream.cc
@@ -47,22 +47,22 @@
 // masked bit of the frames on.
 int CalculateSerializedSizeAndTurnOnMaskBit(
     ScopedVector<WebSocketFrame>* frames) {
-  const int kMaximumTotalSize = std::numeric_limits<int>::max();
+  const uint64 kMaximumTotalSize = std::numeric_limits<int>::max();
 
-  int total_size = 0;
+  uint64 total_size = 0;
   for (WebSocketFrameIterator it = frames->begin(); it != frames->end(); ++it) {
     WebSocketFrame* frame = *it;
     // Force the masked bit on.
     frame->header.masked = true;
     // We enforce flow control so the renderer should never be able to force us
     // to cache anywhere near 2GB of frames.
-    int frame_size = frame->header.payload_length +
-                     GetWebSocketFrameHeaderSize(frame->header);
-    CHECK_GE(kMaximumTotalSize - total_size, frame_size)
+    uint64 frame_size = frame->header.payload_length +
+        GetWebSocketFrameHeaderSize(frame->header);
+    CHECK_LE(frame_size, kMaximumTotalSize - total_size)
         << "Aborting to prevent overflow";
     total_size += frame_size;
   }
-  return total_size;
+  return static_cast<int>(total_size);
 }
 
 }  // namespace
@@ -157,9 +157,9 @@
     dest += result;
     remaining_size -= result;
 
-    const int frame_size = frame->header.payload_length;
+    CHECK_LE(frame->header.payload_length, static_cast<uint64>(remaining_size));
+    const int frame_size = static_cast<int>(frame->header.payload_length);
     if (frame_size > 0) {
-      CHECK_GE(remaining_size, frame_size);
       const char* const frame_data = frame->data->data();
       std::copy(frame_data, frame_data + frame_size, dest);
       MaskWebSocketFramePayload(mask, 0, dest, frame_size);
diff --git a/net/websockets/websocket_basic_stream.h b/net/websockets/websocket_basic_stream.h
index ccfebd8..ed2f195 100644
--- a/net/websockets/websocket_basic_stream.h
+++ b/net/websockets/websocket_basic_stream.h
@@ -44,16 +44,16 @@
 
   // WebSocketStream implementation.
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE;
+                         const CompletionCallback& callback) override;
 
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE;
+                          const CompletionCallback& callback) override;
 
-  virtual void Close() OVERRIDE;
+  virtual void Close() override;
 
-  virtual std::string GetSubProtocol() const OVERRIDE;
+  virtual std::string GetSubProtocol() const override;
 
-  virtual std::string GetExtensions() const OVERRIDE;
+  virtual std::string GetExtensions() const override;
 
   ////////////////////////////////////////////////////////////////////////////
   // Methods for testing only.
diff --git a/net/websockets/websocket_basic_stream_test.cc b/net/websockets/websocket_basic_stream_test.cc
index c67583d..a658fcf 100644
--- a/net/websockets/websocket_basic_stream_test.cc
+++ b/net/websockets/websocket_basic_stream_test.cc
@@ -237,7 +237,7 @@
  protected:
   // All write tests use the same frame, so it is easiest to create it during
   // test creation.
-  virtual void SetUp() OVERRIDE { PrepareWriteFrame(); }
+  virtual void SetUp() override { PrepareWriteFrame(); }
 
   // Creates a WebSocketFrame with a wire format matching kWriteFrame and adds
   // it to |frames_|.
diff --git a/net/websockets/websocket_channel.cc b/net/websockets/websocket_channel.cc
index 8c264f1..9585dc2 100644
--- a/net/websockets/websocket_channel.cc
+++ b/net/websockets/websocket_channel.cc
@@ -85,9 +85,6 @@
   return ((upper - kInvalidRanges) % 2) == 0;
 }
 
-// This function avoids a bunch of boilerplate code.
-void AllowUnused(ChannelState ALLOW_UNUSED unused) {}
-
 // Sets |name| to the name of the frame type for the given |opcode|. Note that
 // for all of Text, Binary and Continuation opcode, this method returns
 // "Data frame".
@@ -141,7 +138,7 @@
   // The total size of the payload data in |frames_|. This will be used to
   // measure the throughput of the link.
   // TODO(ricea): Measure the throughput of the link.
-  size_t total_bytes_;
+  uint64 total_bytes_;
 };
 
 void WebSocketChannel::SendBuffer::AddFrame(scoped_ptr<WebSocketFrame> frame) {
@@ -156,23 +153,23 @@
  public:
   explicit ConnectDelegate(WebSocketChannel* creator) : creator_(creator) {}
 
-  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) OVERRIDE {
+  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) override {
     creator_->OnConnectSuccess(stream.Pass());
     // |this| may have been deleted.
   }
 
-  virtual void OnFailure(const std::string& message) OVERRIDE {
+  virtual void OnFailure(const std::string& message) override {
     creator_->OnConnectFailure(message);
     // |this| has been deleted.
   }
 
   virtual void OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     creator_->OnStartOpeningHandshake(request.Pass());
   }
 
   virtual void OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     creator_->OnFinishOpeningHandshake(response.Pass());
   }
 
@@ -180,7 +177,7 @@
       scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
           ssl_error_callbacks,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {
+      bool fatal) override {
     creator_->OnSSLCertificateError(
         ssl_error_callbacks.Pass(), ssl_info, fatal);
   }
@@ -240,7 +237,7 @@
   // Do nothing if |sender| is already destructed.
   if (sender) {
     WebSocketChannel* channel = sender->owner_;
-    AllowUnused(sender->SendImmediately(channel->event_interface_.get()));
+    sender->SendImmediately(channel->event_interface_.get());
   }
 }
 
@@ -269,8 +266,8 @@
     bool final,
     WebSocketFrameHeader::OpCode opcode,
     const scoped_refptr<IOBuffer>& data,
-    size_t offset,
-    size_t size)
+    uint64 offset,
+    uint64 size)
     : final_(final),
       opcode_(opcode),
       data_(data),
@@ -284,7 +281,7 @@
   opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
 }
 
-void WebSocketChannel::PendingReceivedFrame::DidConsume(size_t bytes) {
+void WebSocketChannel::PendingReceivedFrame::DidConsume(uint64 bytes) {
   DCHECK_LE(offset_, size_);
   DCHECK_LE(bytes, size_ - offset_);
   offset_ += bytes;
@@ -374,7 +371,7 @@
   }
   if (data.size() > base::checked_cast<size_t>(current_send_quota_)) {
     // TODO(ricea): Kill renderer.
-    AllowUnused(
+    ignore_result(
         FailChannel("Send quota exceeded", kWebSocketErrorGoingAway, ""));
     // |this| has been deleted.
     return;
@@ -393,7 +390,7 @@
     if (state == StreamingUtf8Validator::INVALID ||
         (state == StreamingUtf8Validator::VALID_MIDPOINT && fin)) {
       // TODO(ricea): Kill renderer.
-      AllowUnused(
+      ignore_result(
           FailChannel("Browser sent a text frame containing invalid UTF-8",
                       kWebSocketErrorGoingAway,
                       ""));
@@ -410,7 +407,7 @@
   // server is not saturated.
   scoped_refptr<IOBuffer> buffer(new IOBuffer(data.size()));
   std::copy(data.begin(), data.end(), buffer->data());
-  AllowUnused(SendFrameFromIOBuffer(fin, op_code, buffer, data.size()));
+  ignore_result(SendFrameFromIOBuffer(fin, op_code, buffer, data.size()));
   // |this| may have been deleted.
 }
 
@@ -422,13 +419,13 @@
   DCHECK_GE(quota, 0);
   DCHECK_LE(quota, INT_MAX);
   if (!pending_received_frames_.empty()) {
-    DCHECK_EQ(0, current_receive_quota_);
+    DCHECK_EQ(0u, current_receive_quota_);
   }
   while (!pending_received_frames_.empty() && quota > 0) {
     PendingReceivedFrame& front = pending_received_frames_.front();
-    const size_t data_size = front.size() - front.offset();
-    const size_t bytes_to_send =
-        std::min(base::checked_cast<size_t>(quota), data_size);
+    const uint64 data_size = front.size() - front.offset();
+    const uint64 bytes_to_send =
+        std::min(base::checked_cast<uint64>(quota), data_size);
     const bool final = front.final() && data_size == bytes_to_send;
     const char* data =
         front.data().get() ? front.data()->data() + front.offset() : NULL;
@@ -445,9 +442,7 @@
       front.ResetOpcode();
       return;
     }
-    const int64 signed_bytes_to_send = base::checked_cast<int64>(bytes_to_send);
-    DCHECK_GE(quota, signed_bytes_to_send);
-    quota -= signed_bytes_to_send;
+    quota -= bytes_to_send;
 
     pending_received_frames_.pop();
   }
@@ -456,9 +451,9 @@
   const bool start_read =
       current_receive_quota_ == 0 && quota > 0 &&
       (state_ == CONNECTED || state_ == SEND_CLOSED || state_ == CLOSE_WAIT);
-  current_receive_quota_ += base::checked_cast<int>(quota);
+  current_receive_quota_ += quota;
   if (start_read)
-    AllowUnused(ReadFrames());
+    ignore_result(ReadFrames());
   // |this| may have been deleted.
 }
 
@@ -475,7 +470,7 @@
     // Abort the in-progress handshake and drop the connection immediately.
     stream_request_.reset();
     SetState(CLOSED);
-    AllowUnused(DoDropChannel(false, kWebSocketErrorAbnormalClosure, ""));
+    DoDropChannel(false, kWebSocketErrorAbnormalClosure, "");
     return;
   }
   if (state_ != CONNECTED) {
@@ -529,7 +524,7 @@
   if (!socket_url.SchemeIsWSOrWSS()) {
     // TODO(ricea): Kill the renderer (this error should have been caught by
     // Javascript).
-    AllowUnused(event_interface_->OnAddChannelResponse(true, "", ""));
+    ignore_result(event_interface_->OnAddChannelResponse(true, "", ""));
     // |this| is deleted here.
     return;
   }
@@ -568,7 +563,7 @@
   // |stream_request_| is not used once the connection has succeeded.
   stream_request_.reset();
 
-  AllowUnused(ReadFrames());
+  ignore_result(ReadFrames());
   // |this| may have been deleted.
 }
 
@@ -586,7 +581,7 @@
     // |this| has been deleted.
     return;
   }
-  AllowUnused(event_interface_->OnFailChannel(message_copy));
+  ignore_result(event_interface_->OnFailChannel(message_copy));
   // |this| has been deleted.
 }
 
@@ -594,7 +589,7 @@
     scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks> ssl_error_callbacks,
     const SSLInfo& ssl_info,
     bool fatal) {
-  AllowUnused(event_interface_->OnSSLCertificateError(
+  ignore_result(event_interface_->OnSSLCertificateError(
       ssl_error_callbacks.Pass(), socket_url_, ssl_info, fatal));
 }
 
@@ -793,7 +788,7 @@
     const WebSocketFrameHeader::OpCode opcode,
     bool final,
     const scoped_refptr<IOBuffer>& data_buffer,
-    size_t size) {
+    uint64 size) {
   DCHECK_NE(RECV_CLOSED, state_)
       << "HandleFrame() does not support being called re-entrantly from within "
          "SendClose()";
@@ -881,7 +876,7 @@
     WebSocketFrameHeader::OpCode opcode,
     bool final,
     const scoped_refptr<IOBuffer>& data_buffer,
-    size_t size) {
+    uint64 size) {
   if (state_ != CONNECTED) {
     DVLOG(3) << "Ignored data packet received in state " << state_;
     return CHANNEL_ALIVE;
@@ -914,7 +909,7 @@
     // This call is not redundant when size == 0 because it tells us what
     // the current state is.
     StreamingUtf8Validator::State state = incoming_utf8_validator_.AddBytes(
-        size ? data_buffer->data() : NULL, size);
+        size ? data_buffer->data() : NULL, static_cast<size_t>(size));
     if (state == StreamingUtf8Validator::INVALID ||
         (state == StreamingUtf8Validator::VALID_MIDPOINT && final)) {
       return FailChannel("Could not decode a text frame as UTF-8.",
@@ -928,8 +923,7 @@
     return CHANNEL_ALIVE;
 
   initial_frame_forwarded_ = !final;
-  if (size > base::checked_cast<size_t>(current_receive_quota_) ||
-      !pending_received_frames_.empty()) {
+  if (size > current_receive_quota_ || !pending_received_frames_.empty()) {
     const bool no_quota = (current_receive_quota_ == 0);
     DCHECK(no_quota || pending_received_frames_.empty());
     DVLOG(3) << "Queueing frame to renderer due to quota. quota="
@@ -949,7 +943,6 @@
   const char* const data_end = data_begin + size;
   const std::vector<char> data(data_begin, data_end);
   current_receive_quota_ -= size;
-  DCHECK_GE(current_receive_quota_, 0);
 
   // Sends the received frame to the renderer process.
   return event_interface_->OnDataFrame(final, opcode_to_send, data);
@@ -959,7 +952,7 @@
     bool fin,
     WebSocketFrameHeader::OpCode op_code,
     const scoped_refptr<IOBuffer>& buffer,
-    size_t size) {
+    uint64 size) {
   DCHECK(state_ == CONNECTED || state_ == RECV_CLOSED);
   DCHECK(stream_);
 
@@ -1012,7 +1005,7 @@
   DCHECK(state_ == CONNECTED || state_ == RECV_CLOSED);
   DCHECK_LE(reason.size(), kMaximumCloseReasonLength);
   scoped_refptr<IOBuffer> body;
-  size_t size = 0;
+  uint64 size = 0;
   if (code == kWebSocketErrorNoStatusReceived) {
     // Special case: translate kWebSocketErrorNoStatusReceived into a Close
     // frame with no payload.
@@ -1042,7 +1035,7 @@
 }
 
 bool WebSocketChannel::ParseClose(const scoped_refptr<IOBuffer>& buffer,
-                                  size_t size,
+                                  uint64 size,
                                   uint16* code,
                                   std::string* reason,
                                   std::string* message) {
@@ -1109,7 +1102,7 @@
 void WebSocketChannel::CloseTimeout() {
   stream_->Close();
   SetState(CLOSED);
-  AllowUnused(DoDropChannel(false, kWebSocketErrorAbnormalClosure, ""));
+  DoDropChannel(false, kWebSocketErrorAbnormalClosure, "");
   // |this| has been deleted.
 }
 
diff --git a/net/websockets/websocket_channel.h b/net/websockets/websocket_channel.h
index 6d5640e..a79ec4b 100644
--- a/net/websockets/websocket_channel.h
+++ b/net/websockets/websocket_channel.h
@@ -130,8 +130,8 @@
     PendingReceivedFrame(bool final,
                          WebSocketFrameHeader::OpCode opcode,
                          const scoped_refptr<IOBuffer>& data,
-                         size_t offset,
-                         size_t size);
+                         uint64 offset,
+                         uint64 size);
     ~PendingReceivedFrame();
 
     bool final() const { return final_; }
@@ -139,10 +139,10 @@
     // ResetOpcode() to Continuation.
     void ResetOpcode();
     const scoped_refptr<IOBuffer>& data() const { return data_; }
-    size_t offset() const { return offset_; }
-    size_t size() const { return size_; }
+    uint64 offset() const { return offset_; }
+    uint64 size() const { return size_; }
     // Increase |offset_| by |bytes|.
-    void DidConsume(size_t bytes);
+    void DidConsume(uint64 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
@@ -154,9 +154,9 @@
     scoped_refptr<IOBuffer> data_;
     // Where to start reading from data_. Everything prior to offset_ has
     // already been sent to the browser.
-    size_t offset_;
+    uint64 offset_;
     // The size of data_.
-    size_t size_;
+    uint64 size_;
   };
 
   // Methods which return a value of type ChannelState may delete |this|. If the
@@ -259,7 +259,7 @@
       const WebSocketFrameHeader::OpCode opcode,
       bool final,
       const scoped_refptr<IOBuffer>& data_buffer,
-      size_t size) WARN_UNUSED_RESULT;
+      uint64 size) WARN_UNUSED_RESULT;
 
   // Forward a received data frame to the renderer, if connected. If
   // |expecting_continuation| is not equal to |expecting_to_read_continuation_|,
@@ -267,7 +267,7 @@
   ChannelState HandleDataFrame(WebSocketFrameHeader::OpCode opcode,
                                bool final,
                                const scoped_refptr<IOBuffer>& data_buffer,
-                               size_t size) WARN_UNUSED_RESULT;
+                               uint64 size) WARN_UNUSED_RESULT;
 
   // Low-level method to send a single frame. Used for both data and control
   // frames. Either sends the frame immediately or buffers it to be scheduled
@@ -277,7 +277,7 @@
   ChannelState SendFrameFromIOBuffer(bool fin,
                                      WebSocketFrameHeader::OpCode op_code,
                                      const scoped_refptr<IOBuffer>& buffer,
-                                     size_t size) WARN_UNUSED_RESULT;
+                                     uint64 size) WARN_UNUSED_RESULT;
 
   // Performs the "Fail the WebSocket Connection" operation as defined in
   // RFC6455. A NotifyFailure message is sent to the renderer with |message|.
@@ -306,7 +306,7 @@
   // then false is returned and |message| is set to an appropriate console
   // message.
   bool ParseClose(const scoped_refptr<IOBuffer>& buffer,
-                  size_t size,
+                  uint64 size,
                   uint16* code,
                   std::string* reason,
                   std::string* message);
@@ -368,7 +368,7 @@
   int current_send_quota_;
   // The remaining amount of quota that the renderer will allow us to send on
   // this logical channel (quota units).
-  int current_receive_quota_;
+  uint64 current_receive_quota_;
 
   // Timer for the closing handshake.
   base::OneShotTimer<WebSocketChannel> timer_;
diff --git a/net/websockets/websocket_channel_test.cc b/net/websockets/websocket_channel_test.cc
index 42c1ed6..6535741 100644
--- a/net/websockets/websocket_channel_test.cc
+++ b/net/websockets/websocket_channel_test.cc
@@ -163,12 +163,12 @@
 
   // We can't use GMock with scoped_ptr.
   ChannelState OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo>) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeRequestInfo>) override {
     OnStartOpeningHandshakeCalled();
     return CHANNEL_ALIVE;
   }
   ChannelState OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo>) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeResponseInfo>) override {
     OnFinishOpeningHandshakeCalled();
     return CHANNEL_ALIVE;
   }
@@ -176,7 +176,7 @@
       scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
       const GURL& url,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {
+      bool fatal) override {
     OnSSLCertificateErrorCalled(
         ssl_error_callbacks.get(), url, ssl_info, fatal);
     return CHANNEL_ALIVE;
@@ -195,39 +195,39 @@
   virtual ChannelState OnAddChannelResponse(
       bool fail,
       const std::string& selected_protocol,
-      const std::string& extensions) OVERRIDE {
+      const std::string& extensions) override {
     return fail ? CHANNEL_DELETED : CHANNEL_ALIVE;
   }
   virtual ChannelState OnDataFrame(bool fin,
                                    WebSocketMessageType type,
-                                   const std::vector<char>& data) OVERRIDE {
+                                   const std::vector<char>& data) override {
     return CHANNEL_ALIVE;
   }
-  virtual ChannelState OnFlowControl(int64 quota) OVERRIDE {
+  virtual ChannelState OnFlowControl(int64 quota) override {
     return CHANNEL_ALIVE;
   }
-  virtual ChannelState OnClosingHandshake() OVERRIDE { return CHANNEL_ALIVE; }
-  virtual ChannelState OnFailChannel(const std::string& message) OVERRIDE {
+  virtual ChannelState OnClosingHandshake() override { return CHANNEL_ALIVE; }
+  virtual ChannelState OnFailChannel(const std::string& message) override {
     return CHANNEL_DELETED;
   }
   virtual ChannelState OnDropChannel(bool was_clean,
                                      uint16 code,
-                                     const std::string& reason) OVERRIDE {
+                                     const std::string& reason) override {
     return CHANNEL_DELETED;
   }
   virtual ChannelState OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     return CHANNEL_ALIVE;
   }
   virtual ChannelState OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     return CHANNEL_ALIVE;
   }
   virtual ChannelState OnSSLCertificateError(
       scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
       const GURL& url,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {
+      bool fatal) override {
     return CHANNEL_ALIVE;
   }
 };
@@ -246,22 +246,22 @@
       : protocol_(protocol), extensions_(extensions) {}
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE {
+                         const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
   }
 
-  virtual void Close() OVERRIDE {}
+  virtual void Close() override {}
 
   // Returns the string passed to the constructor.
-  virtual std::string GetSubProtocol() const OVERRIDE { return protocol_; }
+  virtual std::string GetSubProtocol() const override { return protocol_; }
 
   // Returns the string passed to the constructor.
-  virtual std::string GetExtensions() const OVERRIDE { return extensions_; }
+  virtual std::string GetExtensions() const override { return extensions_; }
 
  private:
   // The string to return from GetSubProtocol().
@@ -493,7 +493,7 @@
   }
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE {
+                         const CompletionCallback& callback) override {
     CHECK(!read_frames_pending_);
     if (index_ >= responses_.size())
       return ERR_IO_PENDING;
@@ -550,7 +550,7 @@
 class WriteableFakeWebSocketStream : public FakeWebSocketStream {
  public:
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return OK;
   }
 };
@@ -559,7 +559,7 @@
 class UnWriteableFakeWebSocketStream : public FakeWebSocketStream {
  public:
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     return ERR_CONNECTION_RESET;
   }
 };
@@ -575,7 +575,7 @@
   EchoeyFakeWebSocketStream() : read_frames_(NULL), done_(false) {}
 
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     // Users of WebSocketStream will not expect the ReadFrames() callback to be
     // called from within WriteFrames(), so post it to the message loop instead.
     stored_frames_.insert(stored_frames_.end(), frames->begin(), frames->end());
@@ -585,7 +585,7 @@
   }
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE {
+                         const CompletionCallback& callback) override {
     read_callback_ = callback;
     read_frames_ = frames;
     if (done_)
@@ -648,7 +648,7 @@
   ResetOnWriteFakeWebSocketStream() : closed_(false), weak_ptr_factory_(this) {}
 
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE {
+                          const CompletionCallback& callback) override {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ResetOnWriteFakeWebSocketStream::CallCallbackUnlessClosed,
@@ -665,12 +665,12 @@
   }
 
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE {
+                         const CompletionCallback& callback) override {
     read_callback_ = callback;
     return ERR_IO_PENDING;
   }
 
-  virtual void Close() OVERRIDE { closed_ = true; }
+  virtual void Close() override { closed_ = true; }
 
  private:
   void CallCallbackUnlessClosed(const CompletionCallback& callback, int value) {
@@ -736,8 +736,8 @@
 class FakeSSLErrorCallbacks
     : public WebSocketEventInterface::SSLErrorCallbacks {
  public:
-  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) OVERRIDE {}
-  virtual void ContinueSSLRequest() OVERRIDE {}
+  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) override {}
+  virtual void ContinueSSLRequest() override {}
 };
 
 // Base class for all test fixtures.
@@ -850,7 +850,7 @@
                   EVENT_ON_SSL_CERTIFICATE_ERROR) {}
   // Create a ChannelDeletingFakeWebSocketEventInterface. Defined out-of-line to
   // avoid circular dependency.
-  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() OVERRIDE;
+  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() override;
 
   // Tests can set deleting_ to a bitmap of EventInterfaceCall members that they
   // want to cause Channel deletion. The default is for all calls to cause
@@ -870,47 +870,47 @@
   virtual ChannelState OnAddChannelResponse(
       bool fail,
       const std::string& selected_protocol,
-      const std::string& extensions) OVERRIDE {
+      const std::string& extensions) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_ADD_CHANNEL_RESPONSE);
   }
 
   virtual ChannelState OnDataFrame(bool fin,
                                    WebSocketMessageType type,
-                                   const std::vector<char>& data) OVERRIDE {
+                                   const std::vector<char>& data) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_DATA_FRAME);
   }
 
-  virtual ChannelState OnFlowControl(int64 quota) OVERRIDE {
+  virtual ChannelState OnFlowControl(int64 quota) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FLOW_CONTROL);
   }
 
-  virtual ChannelState OnClosingHandshake() OVERRIDE {
+  virtual ChannelState OnClosingHandshake() override {
     return fixture_->DeleteIfDeleting(EVENT_ON_CLOSING_HANDSHAKE);
   }
 
-  virtual ChannelState OnFailChannel(const std::string& message) OVERRIDE {
+  virtual ChannelState OnFailChannel(const std::string& message) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FAIL_CHANNEL);
   }
 
   virtual ChannelState OnDropChannel(bool was_clean,
                                      uint16 code,
-                                     const std::string& reason) OVERRIDE {
+                                     const std::string& reason) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_DROP_CHANNEL);
   }
 
   virtual ChannelState OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_START_OPENING_HANDSHAKE);
   }
   virtual ChannelState OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_FINISH_OPENING_HANDSHAKE);
   }
   virtual ChannelState OnSSLCertificateError(
       scoped_ptr<SSLErrorCallbacks> ssl_error_callbacks,
       const GURL& url,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {
+      bool fatal) override {
     return fixture_->DeleteIfDeleting(EVENT_ON_SSL_CERTIFICATE_ERROR);
   }
 
@@ -949,7 +949,7 @@
   // object before calling CreateChannelAndConnect() or
   // CreateChannelAndConnectSuccessfully(). This will only work once per test
   // case, but once should be enough.
-  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() OVERRIDE {
+  virtual scoped_ptr<WebSocketEventInterface> CreateEventInterface() override {
     return scoped_ptr<WebSocketEventInterface>(event_interface_.release());
   }
 
@@ -963,7 +963,7 @@
   WebSocketChannelStreamTest()
       : mock_stream_(new StrictMock<MockWebSocketStream>) {}
 
-  virtual void CreateChannelAndConnectSuccessfully() OVERRIDE {
+  virtual void CreateChannelAndConnectSuccessfully() override {
     set_stream(mock_stream_.Pass());
     WebSocketChannelTest::CreateChannelAndConnectSuccessfully();
   }
@@ -3317,7 +3317,7 @@
  protected:
   WebSocketChannelStreamTimeoutTest() {}
 
-  virtual void CreateChannelAndConnectSuccessfully() OVERRIDE {
+  virtual void CreateChannelAndConnectSuccessfully() override {
     set_stream(mock_stream_.Pass());
     CreateChannelAndConnect();
     channel_->SendFlowControl(kPlentyOfQuota);
diff --git a/net/websockets/websocket_deflate_predictor_impl.h b/net/websockets/websocket_deflate_predictor_impl.h
index 88a919c..d6b52c4 100644
--- a/net/websockets/websocket_deflate_predictor_impl.h
+++ b/net/websockets/websocket_deflate_predictor_impl.h
@@ -21,9 +21,9 @@
   virtual ~WebSocketDeflatePredictorImpl() {}
 
   virtual Result Predict(const ScopedVector<WebSocketFrame>& frames,
-                         size_t frame_index) OVERRIDE;
-  virtual void RecordInputDataFrame(const WebSocketFrame* frame) OVERRIDE;
-  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) OVERRIDE;
+                         size_t frame_index) override;
+  virtual void RecordInputDataFrame(const WebSocketFrame* frame) override;
+  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) override;
 };
 
 }  // namespace net
diff --git a/net/websockets/websocket_deflate_stream.cc b/net/websockets/websocket_deflate_stream.cc
index f3d293a..6666bef 100644
--- a/net/websockets/websocket_deflate_stream.cc
+++ b/net/websockets/websocket_deflate_stream.cc
@@ -133,8 +133,9 @@
       current_writing_opcode_ = WebSocketFrameHeader::kOpCodeContinuation;
     } else {
       if (frame->data.get() &&
-          !deflater_.AddBytes(frame->data->data(),
-                              frame->header.payload_length)) {
+          !deflater_.AddBytes(
+              frame->data->data(),
+              static_cast<size_t>(frame->header.payload_length))) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "deflater_.AddBytes() returns an error.";
         return ERR_WS_PROTOCOL_ERROR;
@@ -312,8 +313,9 @@
     } else {
       DCHECK_EQ(reading_state_, READING_COMPRESSED_MESSAGE);
       if (frame->data.get() &&
-          !inflater_.AddBytes(frame->data->data(),
-                              frame->header.payload_length)) {
+          !inflater_.AddBytes(
+              frame->data->data(),
+              static_cast<size_t>(frame->header.payload_length))) {
         DVLOG(1) << "WebSocket protocol error. "
                  << "inflater_.AddBytes() returns an error.";
         return ERR_WS_PROTOCOL_ERROR;
diff --git a/net/websockets/websocket_deflate_stream.h b/net/websockets/websocket_deflate_stream.h
index 39ac2df..8f939ec 100644
--- a/net/websockets/websocket_deflate_stream.h
+++ b/net/websockets/websocket_deflate_stream.h
@@ -47,12 +47,12 @@
 
   // WebSocketStream functions.
   virtual int ReadFrames(ScopedVector<WebSocketFrame>* frames,
-                         const CompletionCallback& callback) OVERRIDE;
+                         const CompletionCallback& callback) override;
   virtual int WriteFrames(ScopedVector<WebSocketFrame>* frames,
-                          const CompletionCallback& callback) OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual std::string GetSubProtocol() const OVERRIDE;
-  virtual std::string GetExtensions() const OVERRIDE;
+                          const CompletionCallback& callback) override;
+  virtual void Close() override;
+  virtual std::string GetSubProtocol() const override;
+  virtual std::string GetExtensions() const override;
 
  private:
   enum ReadingState {
diff --git a/net/websockets/websocket_deflate_stream_test.cc b/net/websockets/websocket_deflate_stream_test.cc
index 590f616..4f1c418 100644
--- a/net/websockets/websocket_deflate_stream_test.cc
+++ b/net/websockets/websocket_deflate_stream_test.cc
@@ -125,10 +125,10 @@
 
   // WebSocketDeflatePredictor functions.
   virtual Result Predict(const ScopedVector<WebSocketFrame>& frames,
-                         size_t frame_index) OVERRIDE {
+                         size_t frame_index) override {
     return result_;
   }
-  virtual void RecordInputDataFrame(const WebSocketFrame* frame) OVERRIDE {
+  virtual void RecordInputDataFrame(const WebSocketFrame* frame) override {
     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
       ADD_FAILURE() << "Control frames should not be recorded.";
       return;
@@ -147,7 +147,7 @@
     }
     frames_to_be_input_.pop_front();
   }
-  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) OVERRIDE {
+  virtual void RecordWrittenDataFrame(const WebSocketFrame* frame) override {
     if (!WebSocketFrameHeader::IsKnownDataOpCode(frame->header.opcode)) {
       ADD_FAILURE() << "Control frames should not be recorded.";
       return;
diff --git a/net/websockets/websocket_frame_parser.cc b/net/websockets/websocket_frame_parser.cc
index 2e4c58f..d00a1d1 100644
--- a/net/websockets/websocket_frame_parser.cc
+++ b/net/websockets/websocket_frame_parser.cc
@@ -171,13 +171,11 @@
 
 scoped_ptr<WebSocketFrameChunk> WebSocketFrameParser::DecodeFramePayload(
     bool first_chunk) {
-  const char* current = &buffer_.front() + current_read_pos_;
-  const char* end = &buffer_.front() + buffer_.size();
-  uint64 next_size = std::min<uint64>(
-      end - current, current_frame_header_->payload_length - frame_offset_);
-  // This check must pass because |payload_length| is already checked to be
+  // The cast here is safe because |payload_length| is already checked to be
   // less than std::numeric_limits<int>::max() when the header is parsed.
-  DCHECK_LE(next_size, static_cast<uint64>(kint32max));
+  int next_size = static_cast<int>(std::min(
+      static_cast<uint64>(buffer_.size() - current_read_pos_),
+      current_frame_header_->payload_length - frame_offset_));
 
   scoped_ptr<WebSocketFrameChunk> frame_chunk(new WebSocketFrameChunk);
   if (first_chunk) {
@@ -187,7 +185,7 @@
   if (next_size) {
     frame_chunk->data = new IOBufferWithSize(static_cast<int>(next_size));
     char* io_data = frame_chunk->data->data();
-    memcpy(io_data, current, next_size);
+    memcpy(io_data, &buffer_.front() + current_read_pos_, next_size);
     if (current_frame_header_->masked) {
       // The masking function is its own inverse, so we use the same function to
       // unmask as to mask.
diff --git a/net/websockets/websocket_handshake_stream_create_helper.h b/net/websockets/websocket_handshake_stream_create_helper.h
index fd9ab74..aad2644 100644
--- a/net/websockets/websocket_handshake_stream_create_helper.h
+++ b/net/websockets/websocket_handshake_stream_create_helper.h
@@ -38,12 +38,12 @@
   // Create a WebSocketBasicHandshakeStream.
   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
-      bool using_proxy) OVERRIDE;
+      bool using_proxy) override;
 
   // Unimplemented as of November 2013.
   virtual WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<SpdySession>& session,
-      bool use_relative_url) OVERRIDE;
+      bool use_relative_url) override;
 
   // Call Upgrade() on the WebSocketHandshakeStream and return the result. This
   // must only be called if the handshake succeeded.
diff --git a/net/websockets/websocket_handshake_stream_create_helper_test.cc b/net/websockets/websocket_handshake_stream_create_helper_test.cc
index 88b868f..a776acd 100644
--- a/net/websockets/websocket_handshake_stream_create_helper_test.cc
+++ b/net/websockets/websocket_handshake_stream_create_helper_test.cc
@@ -61,17 +61,17 @@
  public:
   virtual ~TestConnectDelegate() {}
 
-  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) OVERRIDE {}
-  virtual void OnFailure(const std::string& failure_message) OVERRIDE {}
+  virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) override {}
+  virtual void OnFailure(const std::string& failure_message) override {}
   virtual void OnStartOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {}
+      scoped_ptr<WebSocketHandshakeRequestInfo> request) override {}
   virtual void OnFinishOpeningHandshake(
-      scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {}
+      scoped_ptr<WebSocketHandshakeResponseInfo> response) override {}
   virtual void OnSSLCertificateError(
       scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
           ssl_error_callbacks,
       const SSLInfo& ssl_info,
-      bool fatal) OVERRIDE {}
+      bool fatal) override {}
 };
 
 class WebSocketHandshakeStreamCreateHelperTest : public ::testing::Test {
diff --git a/net/websockets/websocket_job.h b/net/websockets/websocket_job.h
index 2e90a24..924fdd0 100644
--- a/net/websockets/websocket_job.h
+++ b/net/websockets/websocket_job.h
@@ -50,37 +50,37 @@
   static void EnsureInit();
 
   State state() const { return state_; }
-  virtual void Connect() OVERRIDE;
-  virtual bool SendData(const char* data, int len) OVERRIDE;
-  virtual void Close() OVERRIDE;
-  virtual void RestartWithAuth(const AuthCredentials& credentials) OVERRIDE;
-  virtual void DetachDelegate() OVERRIDE;
+  virtual void Connect() override;
+  virtual bool SendData(const char* data, int len) override;
+  virtual void Close() override;
+  virtual void RestartWithAuth(const AuthCredentials& credentials) override;
+  virtual void DetachDelegate() override;
 
   // SocketStream::Delegate methods.
   virtual int OnStartOpenConnection(
-      SocketStream* socket, const CompletionCallback& callback) OVERRIDE;
+      SocketStream* socket, const CompletionCallback& callback) override;
   virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) OVERRIDE;
-  virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE;
+                           int max_pending_send_allowed) override;
+  virtual void OnSentData(SocketStream* socket, int amount_sent) override;
   virtual void OnReceivedData(SocketStream* socket,
                               const char* data,
-                              int len) OVERRIDE;
-  virtual void OnClose(SocketStream* socket) OVERRIDE;
+                              int len) override;
+  virtual void OnClose(SocketStream* socket) override;
   virtual void OnAuthRequired(
-      SocketStream* socket, AuthChallengeInfo* auth_info) OVERRIDE;
+      SocketStream* socket, AuthChallengeInfo* auth_info) override;
   virtual void OnSSLCertificateError(SocketStream* socket,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE;
-  virtual void OnError(const SocketStream* socket, int error) OVERRIDE;
+                                     bool fatal) override;
+  virtual void OnError(const SocketStream* socket, int error) override;
 
   // SpdyWebSocketStream::Delegate methods.
-  virtual void OnCreatedSpdyStream(int status) OVERRIDE;
-  virtual void OnSentSpdyHeaders() OVERRIDE;
+  virtual void OnCreatedSpdyStream(int status) override;
+  virtual void OnSentSpdyHeaders() override;
   virtual void OnSpdyResponseHeadersUpdated(
-      const SpdyHeaderBlock& response_headers) OVERRIDE;
-  virtual void OnSentSpdyData(size_t bytes_sent) OVERRIDE;
-  virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) OVERRIDE;
-  virtual void OnCloseSpdyStream() OVERRIDE;
+      const SpdyHeaderBlock& response_headers) override;
+  virtual void OnSentSpdyData(size_t bytes_sent) override;
+  virtual void OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) override;
+  virtual void OnCloseSpdyStream() override;
 
  private:
   friend class WebSocketThrottle;
diff --git a/net/websockets/websocket_job_test.cc b/net/websockets/websocket_job_test.cc
index 59d529a..9cf3144 100644
--- a/net/websockets/websocket_job_test.cc
+++ b/net/websockets/websocket_job_test.cc
@@ -45,18 +45,18 @@
                    URLRequestContext* context, CookieStore* cookie_store)
       : SocketStream(url, delegate, context, cookie_store) {}
 
-  virtual void Connect() OVERRIDE {}
-  virtual bool SendData(const char* data, int len) OVERRIDE {
+  virtual void Connect() override {}
+  virtual bool SendData(const char* data, int len) override {
     sent_data_ += std::string(data, len);
     return true;
   }
 
-  virtual void Close() OVERRIDE {}
+  virtual void Close() override {}
   virtual void RestartWithAuth(
-      const AuthCredentials& credentials) OVERRIDE {
+      const AuthCredentials& credentials) override {
   }
 
-  virtual void DetachDelegate() OVERRIDE {
+  virtual void DetachDelegate() override {
     delegate_ = NULL;
   }
 
@@ -98,40 +98,40 @@
 
   virtual int OnStartOpenConnection(
       SocketStream* socket,
-      const CompletionCallback& callback) OVERRIDE {
+      const CompletionCallback& callback) override {
     if (!on_start_open_connection_.is_null())
       on_start_open_connection_.Run();
     return OK;
   }
   virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) OVERRIDE {
+                           int max_pending_send_allowed) override {
     if (!on_connected_.is_null())
       on_connected_.Run();
   }
   virtual void OnSentData(SocketStream* socket,
-                          int amount_sent) OVERRIDE {
+                          int amount_sent) override {
     amount_sent_ += amount_sent;
     if (!on_sent_data_.is_null())
       on_sent_data_.Run();
   }
   virtual void OnReceivedData(SocketStream* socket,
-                              const char* data, int len) OVERRIDE {
+                              const char* data, int len) override {
     received_data_ += std::string(data, len);
     if (!on_received_data_.is_null())
       on_received_data_.Run();
   }
-  virtual void OnClose(SocketStream* socket) OVERRIDE {
+  virtual void OnClose(SocketStream* socket) override {
     if (!on_close_.is_null())
       on_close_.Run();
   }
   virtual bool CanGetCookies(SocketStream* socket,
-                             const GURL& url) OVERRIDE {
+                             const GURL& url) override {
     return allow_all_cookies_;
   }
   virtual bool CanSetCookie(SocketStream* request,
                             const GURL& url,
                             const std::string& cookie_line,
-                            CookieOptions* options) OVERRIDE {
+                            CookieOptions* options) override {
     return allow_all_cookies_;
   }
 
@@ -190,7 +190,7 @@
       const GURL& url,
       const std::string& cookie_line,
       const CookieOptions& options,
-      const SetCookiesCallback& callback) OVERRIDE {
+      const SetCookiesCallback& callback) override {
     bool result = SetCookieWithOptions(url, cookie_line, options);
     if (!callback.is_null())
       callback.Run(result);
@@ -199,27 +199,27 @@
   virtual void GetCookiesWithOptionsAsync(
       const GURL& url,
       const CookieOptions& options,
-      const GetCookiesCallback& callback) OVERRIDE {
+      const GetCookiesCallback& callback) override {
     if (!callback.is_null())
       callback.Run(GetCookiesWithOptions(url, options));
   }
 
   virtual void GetAllCookiesForURLAsync(
       const GURL& url,
-      const GetCookieListCallback& callback) OVERRIDE {
+      const GetCookieListCallback& callback) override {
     ADD_FAILURE();
   }
 
   virtual void DeleteCookieAsync(const GURL& url,
                                  const std::string& cookie_name,
-                                 const base::Closure& callback) OVERRIDE {
+                                 const base::Closure& callback) override {
     ADD_FAILURE();
   }
 
   virtual void DeleteAllCreatedBetweenAsync(
       const base::Time& delete_begin,
       const base::Time& delete_end,
-      const DeleteCallback& callback) OVERRIDE {
+      const DeleteCallback& callback) override {
     ADD_FAILURE();
   }
 
@@ -227,15 +227,15 @@
       const base::Time delete_begin,
       const base::Time delete_end,
       const GURL& url,
-      const DeleteCallback& callback) OVERRIDE {
+      const DeleteCallback& callback) override {
     ADD_FAILURE();
   }
 
-  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) OVERRIDE {
+  virtual void DeleteSessionCookiesAsync(const DeleteCallback&) override {
     ADD_FAILURE();
   }
 
-  virtual CookieMonster* GetCookieMonster() OVERRIDE { return NULL; }
+  virtual CookieMonster* GetCookieMonster() override { return NULL; }
 
   const std::vector<Entry>& entries() const { return entries_; }
 
@@ -248,7 +248,7 @@
 
 class MockSSLConfigService : public SSLConfigService {
  public:
-  virtual void GetSSLConfig(SSLConfig* config) OVERRIDE {}
+  virtual void GetSSLConfig(SSLConfig* config) override {}
 
  protected:
   virtual ~MockSSLConfigService() {}
@@ -298,17 +298,17 @@
 
   virtual int CreateTransaction(
       RequestPriority priority,
-      scoped_ptr<HttpTransaction>* trans) OVERRIDE {
+      scoped_ptr<HttpTransaction>* trans) override {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
-  virtual HttpCache* GetCache() OVERRIDE {
+  virtual HttpCache* GetCache() override {
     NOTREACHED();
     return NULL;
   }
 
-  virtual HttpNetworkSession* GetSession() OVERRIDE {
+  virtual HttpNetworkSession* GetSession() override {
     return http_session_.get();
   }
 
@@ -350,34 +350,34 @@
   // OnStartOpenConnection() is not implemented by SocketStreamDispatcherHost
 
   virtual void OnConnected(SocketStream* socket,
-                           int max_pending_send_allowed) OVERRIDE {
+                           int max_pending_send_allowed) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnSentData(SocketStream* socket, int amount_sent) OVERRIDE {
+  virtual void OnSentData(SocketStream* socket, int amount_sent) override {
     DeleteJobMaybe();
   }
 
   virtual void OnReceivedData(SocketStream* socket,
                               const char* data,
-                              int len) OVERRIDE {
+                              int len) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnClose(SocketStream* socket) OVERRIDE { DeleteJobMaybe(); }
+  virtual void OnClose(SocketStream* socket) override { DeleteJobMaybe(); }
 
   virtual void OnAuthRequired(SocketStream* socket,
-                              AuthChallengeInfo* auth_info) OVERRIDE {
+                              AuthChallengeInfo* auth_info) override {
     DeleteJobMaybe();
   }
 
   virtual void OnSSLCertificateError(SocketStream* socket,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE {
+                                     bool fatal) override {
     DeleteJobMaybe();
   }
 
-  virtual void OnError(const SocketStream* socket, int error) OVERRIDE {
+  virtual void OnError(const SocketStream* socket, int error) override {
     DeleteJobMaybe();
   }
 
@@ -398,12 +398,12 @@
       : spdy_util_(GetParam()),
         enable_websocket_over_spdy_(false) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     stream_type_ = STREAM_INVALID;
     cookie_store_ = new MockCookieStore;
     context_.reset(new MockURLRequestContext(cookie_store_.get()));
   }
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     cookie_store_ = NULL;
     context_.reset();
     websocket_ = NULL;
diff --git a/net/websockets/websocket_stream.cc b/net/websockets/websocket_stream.cc
index be2bc16..90cb7ca 100644
--- a/net/websockets/websocket_stream.cc
+++ b/net/websockets/websocket_stream.cc
@@ -56,7 +56,7 @@
   // Implementation of URLRequest::Delegate methods.
   virtual void OnReceivedRedirect(URLRequest* request,
                                   const RedirectInfo& redirect_info,
-                                  bool* defer_redirect) OVERRIDE {
+                                  bool* defer_redirect) override {
     // HTTP status codes returned by HttpStreamParser are filtered by
     // WebSocketBasicHandshakeStream, and only 101, 401 and 407 are permitted
     // back up the stack to HttpNetworkTransaction. In particular, redirect
@@ -65,20 +65,20 @@
     NOTREACHED();
   }
 
-  virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
+  virtual void OnResponseStarted(URLRequest* request) override;
 
   virtual void OnAuthRequired(URLRequest* request,
-                              AuthChallengeInfo* auth_info) OVERRIDE;
+                              AuthChallengeInfo* auth_info) override;
 
   virtual void OnCertificateRequested(URLRequest* request,
                                       SSLCertRequestInfo* cert_request_info)
-      OVERRIDE;
+      override;
 
   virtual void OnSSLCertificateError(URLRequest* request,
                                      const SSLInfo& ssl_info,
-                                     bool fatal) OVERRIDE;
+                                     bool fatal) override;
 
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read) OVERRIDE;
+  virtual void OnReadCompleted(URLRequest* request, int bytes_read) override;
 
  private:
   StreamRequestImpl* owner_;
@@ -206,7 +206,7 @@
   explicit SSLErrorCallbacks(URLRequest* url_request)
       : url_request_(url_request) {}
 
-  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) OVERRIDE {
+  virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) override {
     if (ssl_info) {
       url_request_->CancelWithSSLError(error, *ssl_info);
     } else {
@@ -214,7 +214,7 @@
     }
   }
 
-  virtual void ContinueSSLRequest() OVERRIDE {
+  virtual void ContinueSSLRequest() override {
     url_request_->ContinueDespiteLastError();
   }
 
diff --git a/net/websockets/websocket_stream_test.cc b/net/websockets/websocket_stream_test.cc
index c90777f..0b7ae4e 100644
--- a/net/websockets/websocket_stream_test.cc
+++ b/net/websockets/websocket_stream_test.cc
@@ -99,7 +99,7 @@
       : WebSocketHandshakeStreamCreateHelper(connect_delegate,
                                              requested_subprotocols) {}
 
-  virtual void OnStreamCreated(WebSocketBasicHandshakeStream* stream) OVERRIDE {
+  virtual void OnStreamCreated(WebSocketBasicHandshakeStream* stream) override {
     stream->SetWebSocketKeyForTesting("dGhlIHNhbXBsZSBub25jZQ==");
   }
 };
@@ -201,23 +201,23 @@
     explicit TestConnectDelegate(WebSocketStreamCreateTest* owner)
         : owner_(owner) {}
 
-    virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) OVERRIDE {
+    virtual void OnSuccess(scoped_ptr<WebSocketStream> stream) override {
       stream.swap(owner_->stream_);
     }
 
-    virtual void OnFailure(const std::string& message) OVERRIDE {
+    virtual void OnFailure(const std::string& message) override {
       owner_->has_failed_ = true;
       owner_->failure_message_ = message;
     }
 
     virtual void OnStartOpeningHandshake(
-        scoped_ptr<WebSocketHandshakeRequestInfo> request) OVERRIDE {
+        scoped_ptr<WebSocketHandshakeRequestInfo> request) override {
       // Can be called multiple times (in the case of HTTP auth). Last call
       // wins.
       owner_->request_info_ = request.Pass();
     }
     virtual void OnFinishOpeningHandshake(
-        scoped_ptr<WebSocketHandshakeResponseInfo> response) OVERRIDE {
+        scoped_ptr<WebSocketHandshakeResponseInfo> response) override {
       if (owner_->response_info_)
         ADD_FAILURE();
       owner_->response_info_ = response.Pass();
@@ -226,7 +226,7 @@
         scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>
             ssl_error_callbacks,
         const SSLInfo& ssl_info,
-        bool fatal) OVERRIDE {
+        bool fatal) override {
       owner_->ssl_error_callbacks_ = ssl_error_callbacks.Pass();
       owner_->ssl_info_ = ssl_info;
       owner_->ssl_fatal_ = fatal;
@@ -408,7 +408,7 @@
   };
 
   class StreamCreation : public WebSocketStreamCreateTest {
-    virtual void TestBody() OVERRIDE {}
+    virtual void TestBody() override {}
   };
 
   scoped_ptr<base::HistogramSamples> GetSamples(const std::string& name) {
diff --git a/net/websockets/websocket_throttle_test.cc b/net/websockets/websocket_throttle_test.cc
index 4d93001..a743e93 100644
--- a/net/websockets/websocket_throttle_test.cc
+++ b/net/websockets/websocket_throttle_test.cc
@@ -25,12 +25,12 @@
   DummySocketStreamDelegate() {}
   virtual ~DummySocketStreamDelegate() {}
   virtual void OnConnected(
-      SocketStream* socket, int max_pending_send_allowed) OVERRIDE {}
+      SocketStream* socket, int max_pending_send_allowed) override {}
   virtual void OnSentData(SocketStream* socket,
-                          int amount_sent) OVERRIDE {}
+                          int amount_sent) override {}
   virtual void OnReceivedData(SocketStream* socket,
-                              const char* data, int len) OVERRIDE {}
-  virtual void OnClose(SocketStream* socket) OVERRIDE {}
+                              const char* data, int len) override {}
+  virtual void OnClose(SocketStream* socket) override {}
 };
 
 class WebSocketThrottleTestContext : public TestURLRequestContext {