Use qualified base::make_optional in optional_unittest.cc

Unqualified usage of make_optional causes a compile error if:
 - It's compiler in C++17 mode and <optional> is included.
 - The parameter of make_optional is in std namespace, such as
   std::string.
As std::make_optional is pulled by ADL rule and conflicts to
base::make_optional in this situation.

This CL replaces them with qualified base::make_optional, and
replaces others for consistency.

Change-Id: I2045e9eac0e4466dce266112eab5bf7c8555c2ef
Reviewed-on: https://chromium-review.googlesource.com/c/1282512Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Hidehiko Abe <hidehiko@chromium.org>
Commit-Queue: Taiju Tsuiki <tzik@chromium.org>
Cr-Commit-Position: refs/heads/master@{#600361}

base/optional_unittest.cc

@@ -1899,34 +1899,39 @@ TEST(OptionalTest, NotEqualsNull) {
 
 TEST(OptionalTest, MakeOptional) {
   {
-    Optional<float> o = make_optional(32.f);
+    // Use qualified base::make_optional here and elsewhere to avoid the name
+    // confliction to std::make_optional.
+    // The name conflict happens only for types in std namespace, such as
+    // std::string. The other qualified base::make_optional usages are just for
+    // consistency.
+    Optional<float> o = base::make_optional(32.f);
     EXPECT_TRUE(o);
     EXPECT_EQ(32.f, *o);
 
     float value = 3.f;
-    o = make_optional(std::move(value));
+    o = base::make_optional(std::move(value));
     EXPECT_TRUE(o);
     EXPECT_EQ(3.f, *o);
   }
 
   {
-    Optional<std::string> o = make_optional(std::string("foo"));
+    Optional<std::string> o = base::make_optional(std::string("foo"));
     EXPECT_TRUE(o);
     EXPECT_EQ("foo", *o);
 
     std::string value = "bar";
-    o = make_optional(std::move(value));
+    o = base::make_optional(std::move(value));
     EXPECT_TRUE(o);
     EXPECT_EQ(std::string("bar"), *o);
   }
 
   {
-    Optional<TestObject> o = make_optional(TestObject(3, 0.1));
+    Optional<TestObject> o = base::make_optional(TestObject(3, 0.1));
     EXPECT_TRUE(!!o);
     EXPECT_TRUE(TestObject(3, 0.1) == *o);
 
     TestObject value = TestObject(0, 0.42);
-    o = make_optional(std::move(value));
+    o = base::make_optional(std::move(value));
     EXPECT_TRUE(!!o);
     EXPECT_TRUE(TestObject(0, 0.42) == *o);
     EXPECT_EQ(TestObject::State::MOVED_FROM, value.state());
@@ -1945,7 +1950,7 @@ TEST(OptionalTest, MakeOptional) {
       bool c;
     };
 
-    Optional<Test> o = make_optional<Test>(1, 2.0, true);
+    Optional<Test> o = base::make_optional<Test>(1, 2.0, true);
     EXPECT_TRUE(!!o);
     EXPECT_EQ(1, o->a);
     EXPECT_EQ(2.0, o->b);
@@ -1953,11 +1958,11 @@ TEST(OptionalTest, MakeOptional) {
   }
 
   {
-    auto str1 = make_optional<std::string>({'1', '2', '3'});
+    auto str1 = base::make_optional<std::string>({'1', '2', '3'});
     EXPECT_EQ("123", *str1);
 
-    auto str2 =
-        make_optional<std::string>({'a', 'b', 'c'}, std::allocator<char>());
+    auto str2 = base::make_optional<std::string>({'a', 'b', 'c'},
+                                                 std::allocator<char>());
     EXPECT_EQ("abc", *str2);
   }
 }