Revert of Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

chrome/browser/extensions/api/cookies/cookies_unittest.cc

 // 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.
 
 // Tests common functionality used by the Chrome Extensions Cookies API
 // implementation.
 
+#include "testing/gtest/include/gtest/gtest.h"
+
 #include <stddef.h>
 
-#include <utility>
-
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/cookies/cookies_api_constants.h"
 #include "chrome/browser/extensions/api/cookies/cookies_helpers.h"
 #include "chrome/common/extensions/api/cookies.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_constants.h"
-#include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using extensions::api::cookies::Cookie;
 using extensions::api::cookies::CookieStore;
 
 namespace GetAll = extensions::api::cookies::GetAll;
 
 namespace extensions {
 
 namespace keys = cookies_api_constants;
@@ skipping 81 matching lines @@
   ASSERT_NE(nullptr, canonical_cookie2.get());
   Cookie cookie2 =
       cookies_helpers::CreateCookie(*canonical_cookie2, "some cookie store");
   EXPECT_FALSE(cookie2.host_only);
   EXPECT_FALSE(cookie2.session);
   EXPECT_EQ(api::cookies::SAME_SITE_STATUS_STRICT, cookie2.same_site);
   ASSERT_TRUE(cookie2.expiration_date.get());
   EXPECT_EQ(10000, *cookie2.expiration_date);
 
   TestingProfile profile;
-  auto tab_ids_list = base::MakeUnique<base::ListValue>();
+  base::ListValue* tab_ids_list = new base::ListValue();
   std::vector<int> tab_ids;
   CookieStore cookie_store =
-      cookies_helpers::CreateCookieStore(&profile, std::move(tab_ids_list));
+      cookies_helpers::CreateCookieStore(&profile, tab_ids_list);
   EXPECT_EQ("0", cookie_store.id);
   EXPECT_EQ(tab_ids, cookie_store.tab_ids);
 }
 
 TEST_F(ExtensionCookiesTest, GetURLFromCanonicalCookie) {
   std::unique_ptr<net::CanonicalCookie> cookie1(net::CanonicalCookie::Create(
       GURL("http://example.com"), "ABC", "DEF", "example.com", "/",
       base::Time(), base::Time(), false, false,
       net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT));
   ASSERT_NE(nullptr, cookie1.get());
@@ skipping 25 matching lines @@
       {".bar.com", "http://bar.com", "bar.com", true},
       {"bar.com", "http://foo.bar.com", "", true},
       {"bar.com", "http://bar.foo.com", "", false},
       {".bar.com", "http://foo.bar.com", ".foo.bar.com", true},
       {".bar.com", "http://baz.foo.bar.com", "", true},
       {"foo.bar.com", "http://bar.com", ".bar.com", false}};
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
     // Build up the Params struct.
     base::ListValue args;
-    auto dict = base::MakeUnique<base::DictionaryValue>();
+    base::DictionaryValue* dict = new base::DictionaryValue();
     dict->SetString(keys::kDomainKey, std::string(tests[i].filter));
-    args.Set(0, std::move(dict));
+    args.Set(0, dict);
     std::unique_ptr<GetAll::Params> params(GetAll::Params::Create(args));
 
     cookies_helpers::MatchFilter filter(&params->details);
     std::unique_ptr<net::CanonicalCookie> cookie(net::CanonicalCookie::Create(
         GURL(tests[i].url), std::string(), std::string(), tests[i].domain,
         std::string(), base::Time(), base::Time(), false, false,
         net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT));
     ASSERT_NE(nullptr, cookie.get());
     EXPECT_EQ(tests[i].matches, filter.MatchesCookie(*cookie));
   }
 }
 
 TEST_F(ExtensionCookiesTest, DecodeUTF8WithErrorHandling) {
   std::unique_ptr<net::CanonicalCookie> canonical_cookie(
       net::CanonicalCookie::Create(GURL("http://test.com"),
                                    "=011Q255bNX_1!yd\203e+;path=/path\203",
                                    base::Time(), net::CookieOptions()));
   ASSERT_NE(nullptr, canonical_cookie.get());
   Cookie cookie =
       cookies_helpers::CreateCookie(*canonical_cookie, "some cookie store");
   EXPECT_EQ(std::string("011Q255bNX_1!yd\xEF\xBF\xBD"
                         "e+"),
             cookie.value);
   EXPECT_EQ(std::string(), cookie.path);
 }
 
 }  // namespace extensions