BASELINE: Update Chromium to 58.0.3029.54

Change-Id: I67f57065a7afdc8e4614adb5c0230281428df4d1
Reviewed-by: Peter Varga <pvarga@inf.u-szeged.hu>

3 files changed, 45 insertions, 55 deletions

diff --git a/chromium/dbus/bus.cc b/chromium/dbus/bus.cc
index 186c9380d0f..a86971736f7 100644
--- a/chromium/dbus/bus.cc
+++ b/chromium/dbus/bus.cc
@@ -45,7 +45,7 @@ const char kServiceNameOwnerChangeMatchRule[] =
 class Watch : public base::MessagePumpLibevent::Watcher {
  public:
   explicit Watch(DBusWatch* watch)
-      : raw_watch_(watch) {
+      : raw_watch_(watch), file_descriptor_watcher_(FROM_HERE) {
     dbus_watch_set_data(raw_watch_, this, NULL);
   }
 
diff --git a/chromium/dbus/values_util.cc b/chromium/dbus/values_util.cc
index 4367791d4d4..58b2b9ed7f7 100644
--- a/chromium/dbus/values_util.cc
+++ b/chromium/dbus/values_util.cc
@@ -98,38 +98,37 @@ std::unique_ptr<base::Value> PopDataAsValue(MessageReader* reader) {
     case Message::BYTE: {
       uint8_t value = 0;
       if (reader->PopByte(&value))
-        result = base::MakeUnique<base::FundamentalValue>(value);
+        result = base::MakeUnique<base::Value>(value);
       break;
     }
     case Message::BOOL: {
       bool value = false;
       if (reader->PopBool(&value))
-        result = base::MakeUnique<base::FundamentalValue>(value);
+        result = base::MakeUnique<base::Value>(value);
       break;
     }
     case Message::INT16: {
       int16_t value = 0;
       if (reader->PopInt16(&value))
-        result = base::MakeUnique<base::FundamentalValue>(value);
+        result = base::MakeUnique<base::Value>(value);
       break;
     }
     case Message::UINT16: {
       uint16_t value = 0;
       if (reader->PopUint16(&value))
-        result = base::MakeUnique<base::FundamentalValue>(value);
+        result = base::MakeUnique<base::Value>(value);
       break;
     }
     case Message::INT32: {
       int32_t value = 0;
       if (reader->PopInt32(&value))
-        result = base::MakeUnique<base::FundamentalValue>(value);
+        result = base::MakeUnique<base::Value>(value);
       break;
     }
     case Message::UINT32: {
       uint32_t value = 0;
       if (reader->PopUint32(&value)) {
-        result = base::MakeUnique<base::FundamentalValue>(
-            static_cast<double>(value));
+        result = base::MakeUnique<base::Value>(static_cast<double>(value));
       }
       break;
     }
@@ -138,8 +137,7 @@ std::unique_ptr<base::Value> PopDataAsValue(MessageReader* reader) {
       if (reader->PopInt64(&value)) {
         DLOG_IF(WARNING, !IsExactlyRepresentableByDouble(value)) <<
             value << " is not exactly representable by double";
-        result = base::MakeUnique<base::FundamentalValue>(
-            static_cast<double>(value));
+        result = base::MakeUnique<base::Value>(static_cast<double>(value));
       }
       break;
     }
@@ -148,15 +146,14 @@ std::unique_ptr<base::Value> PopDataAsValue(MessageReader* reader) {
       if (reader->PopUint64(&value)) {
         DLOG_IF(WARNING, !IsExactlyRepresentableByDouble(value)) <<
             value << " is not exactly representable by double";
-        result = base::MakeUnique<base::FundamentalValue>(
-            static_cast<double>(value));
+        result = base::MakeUnique<base::Value>(static_cast<double>(value));
       }
       break;
     }
     case Message::DOUBLE: {
       double value = 0;
       if (reader->PopDouble(&value))
-        result = base::MakeUnique<base::FundamentalValue>(value);
+        result = base::MakeUnique<base::Value>(value);
       break;
     }
     case Message::STRING: {
diff --git a/chromium/dbus/values_util_unittest.cc b/chromium/dbus/values_util_unittest.cc
index d310d68a485..38d94f824b1 100644
--- a/chromium/dbus/values_util_unittest.cc
+++ b/chromium/dbus/values_util_unittest.cc
@@ -55,50 +55,47 @@ TEST(ValuesUtilTest, PopBasicTypes) {
   // Pop a byte.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kByteValue));
+  expected_value.reset(new base::Value(kByteValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a bool.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kBoolValue));
+  expected_value.reset(new base::Value(kBoolValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int16_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kInt16Value));
+  expected_value.reset(new base::Value(kInt16Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint16_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kUint16Value));
+  expected_value.reset(new base::Value(kUint16Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int32_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kInt32Value));
+  expected_value.reset(new base::Value(kInt32Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint32_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kUint32Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kUint32Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int64_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kInt64Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kInt64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint64_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kUint64Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kUint64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a double.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kDoubleValue));
+  expected_value.reset(new base::Value(kDoubleValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a string.
   value = PopDataAsValue(&reader);
@@ -136,17 +133,17 @@ TEST(ValuesUtilTest, PopVariant) {
   // Pop a bool.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kBoolValue));
+  expected_value.reset(new base::Value(kBoolValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int32_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kInt32Value));
+  expected_value.reset(new base::Value(kInt32Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a double.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(new base::FundamentalValue(kDoubleValue));
+  expected_value.reset(new base::Value(kDoubleValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a string.
   value = PopDataAsValue(&reader);
@@ -173,16 +170,14 @@ TEST(ValuesUtilTest, PopExtremelyLargeIntegers) {
   // Pop an int64_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kInt64Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kInt64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   ASSERT_TRUE(value->GetAsDouble(&double_value));
   EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value));
   // Pop a uint64_t.
   value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
-  expected_value.reset(
-      new base::FundamentalValue(static_cast<double>(kUint64Value)));
+  expected_value.reset(new base::Value(static_cast<double>(kUint64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   ASSERT_TRUE(value->GetAsDouble(&double_value));
   EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value));
@@ -343,12 +338,10 @@ TEST(ValuesUtilTest, PopDictionaryWithDottedStringKey) {
 
   // Create the expected value.
   base::DictionaryValue dictionary_value;
-  dictionary_value.SetWithoutPathExpansion(
-      kKey1, new base::FundamentalValue(kBoolValue));
-  dictionary_value.SetWithoutPathExpansion(
-      kKey2, new base::FundamentalValue(kInt32Value));
-  dictionary_value.SetWithoutPathExpansion(
-      kKey3, new base::FundamentalValue(kDoubleValue));
+  dictionary_value.SetWithoutPathExpansion(kKey1, new base::Value(kBoolValue));
+  dictionary_value.SetWithoutPathExpansion(kKey2, new base::Value(kInt32Value));
+  dictionary_value.SetWithoutPathExpansion(kKey3,
+                                           new base::Value(kDoubleValue));
 
   // Pop a dictinoary.
   MessageReader reader(response.get());
@@ -383,7 +376,7 @@ TEST(ValuesUtilTest, PopDoubleToIntDictionary) {
   base::DictionaryValue dictionary_value;
   for (size_t i = 0; i != values.size(); ++i) {
     std::string key_string;
-    base::JSONWriter::Write(base::FundamentalValue(keys[i]), &key_string);
+    base::JSONWriter::Write(base::Value(keys[i]), &key_string);
     dictionary_value.SetIntegerWithoutPathExpansion(key_string, values[i]);
   }
 
@@ -395,9 +388,9 @@ TEST(ValuesUtilTest, PopDoubleToIntDictionary) {
 }
 
 TEST(ValuesUtilTest, AppendBasicTypes) {
-  const base::FundamentalValue kBoolValue(false);
-  const base::FundamentalValue kIntegerValue(42);
-  const base::FundamentalValue kDoubleValue(4.2);
+  const base::Value kBoolValue(false);
+  const base::Value kIntegerValue(42);
+  const base::Value kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
@@ -424,9 +417,9 @@ TEST(ValuesUtilTest, AppendBasicTypes) {
 }
 
 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) {
-  const base::FundamentalValue kBoolValue(false);
-  const base::FundamentalValue kIntegerValue(42);
-  const base::FundamentalValue kDoubleValue(4.2);
+  const base::Value kBoolValue(false);
+  const base::Value kIntegerValue(42);
+  const base::Value kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
@@ -453,9 +446,9 @@ TEST(ValuesUtilTest, AppendBasicTypesAsVariant) {
 }
 
 TEST(ValuesUtilTest, AppendValueDataBasicTypes) {
-  const base::FundamentalValue kBoolValue(false);
-  const base::FundamentalValue kIntegerValue(42);
-  const base::FundamentalValue kDoubleValue(4.2);
+  const base::Value kBoolValue(false);
+  const base::Value kIntegerValue(42);
+  const base::Value kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
@@ -482,9 +475,9 @@ TEST(ValuesUtilTest, AppendValueDataBasicTypes) {
 }
 
 TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) {
-  const base::FundamentalValue kBoolValue(false);
-  const base::FundamentalValue kIntegerValue(42);
-  const base::FundamentalValue kDoubleValue(4.2);
+  const base::Value kBoolValue(false);
+  const base::Value kIntegerValue(42);
+  const base::Value kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
@@ -543,7 +536,7 @@ TEST(ValuesUtilTest, AppendDictionary) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueData(&writer, test_dictionary);
-  base::FundamentalValue int_value(kInt32Value);
+  base::Value int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
@@ -590,7 +583,7 @@ TEST(ValuesUtilTest, AppendDictionaryAsVariant) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueDataAsVariant(&writer, test_dictionary);
-  base::FundamentalValue int_value(kInt32Value);
+  base::Value int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
@@ -634,7 +627,7 @@ TEST(ValuesUtilTest, AppendList) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueData(&writer, test_list);
-  base::FundamentalValue int_value(kInt32Value);
+  base::Value int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
@@ -678,7 +671,7 @@ TEST(ValuesUtilTest, AppendListAsVariant) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueDataAsVariant(&writer, test_list);
-  base::FundamentalValue int_value(kInt32Value);
+  base::Value int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.