Update code to current Chromium master

This corresponds to:

Chromium: 6555f9456074c0c0e5f7713564b978588ac04a5d
webrtc: c8b569e0a7ad0b369e15f0197b3a558699ec8efa

webrtc/base/BUILD.gn

@@ -94,6 +94,7 @@ static_library("rtc_base_approved") {
   public_configs = [ "..:common_inherited_config" ]
 
   sources = [
+    "array_view.h",
     "atomicops.h",
     "bitbuffer.cc",
     "bitbuffer.h",
@@ -114,6 +115,7 @@ static_library("rtc_base_approved") {
     "event_tracer.h",
     "exp_filter.cc",
     "exp_filter.h",
+    "maybe.h",
     "md5.cc",
     "md5.h",
     "md5digest.cc",
@@ -237,6 +239,8 @@ static_library("rtc_base") {
     "nethelpers.h",
     "network.cc",
     "network.h",
+    "networkmonitor.cc",
+    "networkmonitor.h",
     "nullsocketserver.h",
     "pathutils.cc",
     "pathutils.h",

webrtc/base/checks.h

@@ -164,6 +164,7 @@ DEFINE_RTC_CHECK_OP_IMPL(GT, > )
 // code in debug builds. It does reference the condition parameter in all cases,
 // though, so callers won't risk getting warnings about unused variables.
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
+#define RTC_DCHECK_IS_ON 1
 #define RTC_DCHECK(condition) RTC_CHECK(condition)
 #define RTC_DCHECK_EQ(v1, v2) RTC_CHECK_EQ(v1, v2)
 #define RTC_DCHECK_NE(v1, v2) RTC_CHECK_NE(v1, v2)
@@ -172,6 +173,7 @@ DEFINE_RTC_CHECK_OP_IMPL(GT, > )
 #define RTC_DCHECK_GE(v1, v2) RTC_CHECK_GE(v1, v2)
 #define RTC_DCHECK_GT(v1, v2) RTC_CHECK_GT(v1, v2)
 #else
+#define RTC_DCHECK_IS_ON 0
 #define RTC_DCHECK(condition) RTC_EAT_STREAM_PARAMETERS(condition)
 #define RTC_DCHECK_EQ(v1, v2) RTC_EAT_STREAM_PARAMETERS((v1) == (v2))
 #define RTC_DCHECK_NE(v1, v2) RTC_EAT_STREAM_PARAMETERS((v1) != (v2))

webrtc/base/maybe.h

@@ -0,0 +1,110 @@
+/*
+ *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_BASE_MAYBE_H_
+#define WEBRTC_BASE_MAYBE_H_
+
+#include <algorithm>
+#include <utility>
+
+#include "webrtc/base/checks.h"
+
+namespace rtc {
+
+// Simple std::experimental::optional-wannabe. It either contains a T or not.
+// In order to keep the implementation simple and portable, this implementation
+// actually contains a (default-constructed) T even when it supposedly doesn't
+// contain a value; use e.g. rtc::scoped_ptr<T> instead if that's too
+// expensive.
+//
+// A moved-from Maybe<T> may only be destroyed, and assigned to if T allows
+// being assigned to after having been moved from. Specifically, you may not
+// assume that it just doesn't contain a value anymore.
+//
+// TODO(kwiberg): Get rid of this class when the standard library has
+// std::optional (and we're allowed to use it).
+template <typename T>
+class Maybe final {
+ public:
+  // Construct an empty Maybe.
+  Maybe() : has_value_(false) {}
+
+  // Construct a Maybe that contains a value.
+  explicit Maybe(const T& val) : value_(val), has_value_(true) {}
+  explicit Maybe(T&& val) : value_(static_cast<T&&>(val)), has_value_(true) {}
+
+  // Copy and move constructors.
+  // TODO(kwiberg): =default the move constructor when MSVC supports it.
+  Maybe(const Maybe&) = default;
+  Maybe(Maybe&& m)
+      : value_(static_cast<T&&>(m.value_)), has_value_(m.has_value_) {}
+
+  // Assignment.
+  // TODO(kwiberg): =default the move assignment op when MSVC supports it.
+  Maybe& operator=(const Maybe&) = default;
+  Maybe& operator=(Maybe&& m) {
+    value_ = static_cast<T&&>(m.value_);
+    has_value_ = m.has_value_;
+    return *this;
+  }
+
+  friend void swap(Maybe& m1, Maybe& m2) {
+    using std::swap;
+    swap(m1.value_, m2.value_);
+    swap(m1.has_value_, m2.has_value_);
+  }
+
+  // Conversion to bool to test if we have a value.
+  explicit operator bool() const { return has_value_; }
+
+  // Dereferencing. Only allowed if we have a value.
+  const T* operator->() const {
+    RTC_DCHECK(has_value_);
+    return &value_;
+  }
+  T* operator->() {
+    RTC_DCHECK(has_value_);
+    return &value_;
+  }
+  const T& operator*() const {
+    RTC_DCHECK(has_value_);
+    return value_;
+  }
+  T& operator*() {
+    RTC_DCHECK(has_value_);
+    return value_;
+  }
+
+  // Dereference with a default value in case we don't have a value.
+  const T& value_or(const T& default_val) const {
+    return has_value_ ? value_ : default_val;
+  }
+
+  // Equality tests. Two Maybes are equal if they contain equivalent values, or
+  // if they're both empty.
+  friend bool operator==(const Maybe& m1, const Maybe& m2) {
+    return m1.has_value_ && m2.has_value_ ? m1.value_ == m2.value_
+                                          : m1.has_value_ == m2.has_value_;
+  }
+  friend bool operator!=(const Maybe& m1, const Maybe& m2) {
+    return m1.has_value_ && m2.has_value_ ? m1.value_ != m2.value_
+                                          : m1.has_value_ != m2.has_value_;
+  }
+
+ private:
+  // Invariant: Unless *this has been moved from, value_ is default-initialized
+  // (or copied or moved from a default-initialized T) if !has_value_.
+  T value_;
+  bool has_value_;
+};
+
+}  // namespace rtc
+
+#endif  // WEBRTC_BASE_MAYBE_H_

webrtc/base/stringutils.cc

@@ -77,11 +77,11 @@ size_t asccpyn(wchar_t* buffer, size_t buflen,
   } else if (srclen >= buflen) {
     srclen = buflen - 1;
   }
-#if _DEBUG
+#if !defined(NDEBUG)
   // Double check that characters are not UTF-8
   for (size_t pos = 0; pos < srclen; ++pos)
     RTC_DCHECK_LT(static_cast<unsigned char>(source[pos]), 128);
-#endif  // _DEBUG
+#endif
   std::copy(source, source + srclen, buffer);
   buffer[srclen] = 0;
   return srclen;

webrtc/base/template_util.h

@@ -48,6 +48,19 @@ template <class T> struct is_non_const_reference<const T&> : false_type {};
 template <class T> struct is_void : false_type {};
 template <> struct is_void<void> : true_type {};
 
+template <class T>
+struct remove_reference {
+  typedef T type;
+};
+template <class T>
+struct remove_reference<T&> {
+  typedef T type;
+};
+template <class T>
+struct remove_reference<T&&> {
+  typedef T type;
+};
+
 namespace internal {
 
 // Types YesType and NoType are guaranteed such that sizeof(YesType) <