Revert "Take scheme in CookieStore::SetCanonicalCookieAsync, not just…

… whether it's secure."

This reverts commit 5760a6f.

Reason for revert: Clashed with some other change so all Android builders died with:

[1078/8826] CXX obj/android_webview/common/aw_cookie_manager_wrapper.o
FAILED: obj/android_webview/common/aw_cookie_manager_wrapper.o 
../../android_webview/browser/net_network_service/aw_cookie_manager_wrapper.cc -o obj/android_webview/common/aw_cookie_manager_wrapper.o
../../android_webview/browser/net_network_service/aw_cookie_manager_wrapper.cc:40:43: error: reference to type 'const std::string' (aka 'const basic_string<char, char_traits<char>, allocator<char> >') could not bind to an lvalue of type 'bool'
  cookie_manager_->SetCanonicalCookie(cc, secure_source, modify_http_only,
                                          ^~~~~~~~~~~~~
gen/services/network/public/mojom/cookie_manager.mojom.h:179:82: note: passing argument to parameter 'source_scheme' here
  void SetCanonicalCookie(const net::CanonicalCookie& cookie, const std::string& source_scheme, bool modify_http_only, SetCanonicalCookieCallback callback) final;
                                                                                 ^
1 error generated.


Original change's description:
> Take scheme in CookieStore::SetCanonicalCookieAsync, not just whether it's secure.
> 
> This permits to check it against list of cookieable schemes (fixing #850044), and is
> a prerequisite for getting rid of SetCookieWithOptionsAsync in favor of everything
> using SetCanonicalCookieAsync.
> 
> Bug: 850044
> Change-Id: I890cf266767a124b116fc553932a74b5a97ed943
> Reviewed-on: https://chromium-review.googlesource.com/c/1450420
> Commit-Queue: Maks Orlovich <morlovich@chromium.org>
> Reviewed-by: John Abd-El-Malek <jam@chromium.org>
> Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
> Reviewed-by: Eugene But <eugenebut@chromium.org>
> Reviewed-by: Mike West <mkwst@chromium.org>
> Reviewed-by: Tom Sepez <tsepez@chromium.org>
> Reviewed-by: Victor Costan <pwnall@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#634646}

TBR=jam@chromium.org,caseq@chromium.org,tsepez@chromium.org,eugenebut@chromium.org,pwnall@chromium.org,mkwst@chromium.org,morlovich@chromium.org

Change-Id: I17b82ee596c4cdcebfc8774f06b7e155ead8c514
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 850044
Reviewed-on: https://chromium-review.googlesource.com/c/1482460
Reviewed-by: Daniel Bratell <bratell@opera.com>
Commit-Queue: Daniel Bratell <bratell@opera.com>
Cr-Commit-Position: refs/heads/master@{#634658}

android_webview/browser/net/aw_cookie_store_wrapper.cc

@@ -27,12 +27,11 @@ void SetCookieWithOptionsAsyncOnCookieThread(
 
 void SetCanonicalCookieAsyncOnCookieThread(
     std::unique_ptr<net::CanonicalCookie> cookie,
-    std::string source_scheme,
+    bool secure_source,
     bool modify_http_only,
     net::CookieStore::SetCookiesCallback callback) {
   GetCookieStore()->SetCanonicalCookieAsync(
-      std::move(cookie), std::move(source_scheme), modify_http_only,
-      std::move(callback));
+      std::move(cookie), secure_source, modify_http_only, std::move(callback));
 }
 
 void GetCookieListWithOptionsAsyncOnCookieThread(
@@ -103,13 +102,13 @@ void AwCookieStoreWrapper::SetCookieWithOptionsAsync(
 
 void AwCookieStoreWrapper::SetCanonicalCookieAsync(
     std::unique_ptr<net::CanonicalCookie> cookie,
-    std::string source_scheme,
+    bool secure_source,
     bool modify_http_only,
     SetCookiesCallback callback) {
   DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
   PostTaskToCookieStoreTaskRunner(base::BindOnce(
-      &SetCanonicalCookieAsyncOnCookieThread, std::move(cookie),
-      std::move(source_scheme), modify_http_only,
+      &SetCanonicalCookieAsyncOnCookieThread, std::move(cookie), secure_source,
+      modify_http_only,
       CreateWrappedCallback<net::CanonicalCookie::CookieInclusionStatus>(
           std::move(callback))));
 }

android_webview/browser/net/aw_cookie_store_wrapper.h

@@ -48,7 +48,7 @@ class AwCookieStoreWrapper : public net::CookieStore {
                                  const net::CookieOptions& options,
                                  SetCookiesCallback callback) override;
   void SetCanonicalCookieAsync(std::unique_ptr<net::CanonicalCookie> cookie,
-                               std::string source_scheme,
+                               bool secure_source,
                                bool modify_http_only,
                                SetCookiesCallback callback) override;
   void GetCookieListWithOptionsAsync(const GURL& url,

chrome/browser/android/cookies/cookies_fetcher_util.cc

@@ -111,6 +111,6 @@ static void JNI_CookiesFetcher_RestoreCookies(
   // Assume HTTPS - since the cookies are being restored from another store,
   // they have already gone through the strict secure check.
   GetCookieServiceClient()->SetCanonicalCookie(
-      *cookie, "https", true /* modify_http_only */,
+      *cookie, true /* secure_source */, true /* modify_http_only */,
       network::mojom::CookieManager::SetCanonicalCookieCallback());
 }

chrome/browser/browsing_data/browsing_data_cookie_helper_unittest.cc

@@ -112,34 +112,38 @@ class BrowsingDataCookieHelperTest : public testing::Test {
 
   void CreateCookiesForTest() {
     auto cookie1 =
-        net::CanonicalCookie::Create(GURL("https://www.google.com"), "A=1",
+        net::CanonicalCookie::Create(GURL("http://www.google.com"), "A=1",
+                                     base::Time::Now(), net::CookieOptions());
+    auto cookie2 =
+        net::CanonicalCookie::Create(GURL("http://www.gmail.google.com"), "B=1",
                                      base::Time::Now(), net::CookieOptions());
-    auto cookie2 = net::CanonicalCookie::Create(
-        GURL("https://www.gmail.google.com"), "B=1", base::Time::Now(),
-        net::CookieOptions());
 
     network::mojom::CookieManager* cookie_manager =
         storage_partition()->GetCookieManagerForBrowserProcess();
-    cookie_manager->SetCanonicalCookie(
-        *cookie1, "https", false /* modify_http_only */, base::DoNothing());
-    cookie_manager->SetCanonicalCookie(
-        *cookie2, "https", false /* modify_http_only */, base::DoNothing());
+    cookie_manager->SetCanonicalCookie(*cookie1, true /* secure_source */,
+                                       false /* modify_http_only */,
+                                       base::DoNothing());
+    cookie_manager->SetCanonicalCookie(*cookie2, true /* secure_source */,
+                                       false /* modify_http_only */,
+                                       base::DoNothing());
   }
 
   void CreateCookiesForDomainCookieTest() {
     auto cookie1 =
-        net::CanonicalCookie::Create(GURL("https://www.google.com"), "A=1",
+        net::CanonicalCookie::Create(GURL("http://www.google.com"), "A=1",
                                      base::Time::Now(), net::CookieOptions());
     auto cookie2 = net::CanonicalCookie::Create(
-        GURL("https://www.google.com"), "A=2; Domain=.www.google.com ",
+        GURL("http://www.google.com"), "A=2; Domain=.www.google.com ",
         base::Time::Now(), net::CookieOptions());
 
     network::mojom::CookieManager* cookie_manager =
         storage_partition()->GetCookieManagerForBrowserProcess();
-    cookie_manager->SetCanonicalCookie(
-        *cookie1, "https", false /* modify_http_only */, base::DoNothing());
-    cookie_manager->SetCanonicalCookie(
-        *cookie2, "https", false /* modify_http_only */, base::DoNothing());
+    cookie_manager->SetCanonicalCookie(*cookie1, true /* secure_source */,
+                                       false /* modify_http_only */,
+                                       base::DoNothing());
+    cookie_manager->SetCanonicalCookie(*cookie2, true /* secure_source */,
+                                       false /* modify_http_only */,
+                                       base::DoNothing());
   }
 
   void FetchCallback(const net::CookieList& cookies) {

chrome/browser/browsing_data/browsing_data_remover_browsertest.cc

@@ -282,8 +282,7 @@ bool SetGaiaCookieForProfile(Profile* profile) {
   network::mojom::CookieManager* cookie_manager =
       content::BrowserContext::GetDefaultStoragePartition(profile)
           ->GetCookieManagerForBrowserProcess();
-  cookie_manager->SetCanonicalCookie(cookie, "https", true,
-                                     std::move(callback));
+  cookie_manager->SetCanonicalCookie(cookie, true, true, std::move(callback));
   loop.Run();
   return success;
 }

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc

@@ -283,7 +283,7 @@ class RemoveCookieTester {
     auto cookie = net::CanonicalCookie::Create(
         kOrigin1, "A=1", base::Time::Now(), net::CookieOptions());
     cookie_manager_->SetCanonicalCookie(
-        *cookie, "http", /*modify_http_only=*/false,
+        *cookie, /*secure_source=*/false, /*modify_http_only=*/false,
         base::BindLambdaForTesting([&](bool result) {
           EXPECT_TRUE(result);
           run_loop.Quit();

chrome/browser/browsing_data/counters/site_data_counting_helper_unittest.cc

@@ -57,7 +57,7 @@ class SiteDataCountingHelperTest : public testing::Test {
               time, url.SchemeIsCryptographic(), false,
               net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT);
       cookie_manager->SetCanonicalCookie(
-          *cookie, url.scheme(), true /*modify_http_only*/,
+          *cookie, url.SchemeIsCryptographic(), true /*modify_http_only*/,
           base::BindLambdaForTesting([&](bool result) {
             if (--tasks == 0)
               run_loop.Quit();

chrome/browser/chromeos/android_sms/android_sms_app_setup_controller_impl.cc

@@ -88,7 +88,7 @@ void AndroidSmsAppSetupControllerImpl::SetUpApp(const GURL& app_url,
               base::Time::Now() /* last_access_time */, true /* secure */,
               false /* http_only */, net::CookieSameSite::STRICT_MODE,
               net::COOKIE_PRIORITY_DEFAULT),
-          "https", false /* modify_http_only */,
+          true /* secure_source */, false /* modify_http_only */,
           base::BindOnce(&AndroidSmsAppSetupControllerImpl::
                              OnSetRememberDeviceByDefaultCookieResult,
                          weak_ptr_factory_.GetWeakPtr(), app_url, install_url,
@@ -275,7 +275,7 @@ void AndroidSmsAppSetupControllerImpl::OnAppUninstallResult(
               base::Time::Now() /* last_access_time */, true /* secure */,
               false /* http_only */, net::CookieSameSite::STRICT_MODE,
               net::COOKIE_PRIORITY_DEFAULT),
-          "https", false /* modify_http_only */,
+          true /* secure_source */, false /* modify_http_only */,
           base::BindOnce(
               &AndroidSmsAppSetupControllerImpl::OnSetMigrationCookieResult,
               weak_ptr_factory_.GetWeakPtr(), app_url, std::move(callback)));

chrome/browser/chromeos/android_sms/android_sms_app_setup_controller_impl_unittest.cc

@@ -61,7 +61,7 @@ class FakeCookieManager : public network::TestCookieManager {
   void InvokePendingSetCanonicalCookieCallback(
       const std::string& expected_cookie_name,
       const std::string& expected_cookie_value,
-      const std::string& expected_source_scheme,
+      bool expected_secure_source,
       bool expected_modify_http_only,
       bool success) {
     ASSERT_FALSE(set_canonical_cookie_calls_.empty());
@@ -70,7 +70,7 @@ class FakeCookieManager : public network::TestCookieManager {
 
     EXPECT_EQ(expected_cookie_name, std::get<0>(params).Name());
     EXPECT_EQ(expected_cookie_value, std::get<0>(params).Value());
-    EXPECT_EQ(expected_source_scheme, std::get<1>(params));
+    EXPECT_EQ(expected_secure_source, std::get<1>(params));
     EXPECT_EQ(expected_modify_http_only, std::get<2>(params));
 
     std::move(std::get<3>(params)).Run(success);
@@ -92,11 +92,11 @@ class FakeCookieManager : public network::TestCookieManager {
 
   // network::mojom::CookieManager
   void SetCanonicalCookie(const net::CanonicalCookie& cookie,
-                          const std::string& source_scheme,
+                          bool secure_source,
                           bool modify_http_only,
                           SetCanonicalCookieCallback callback) override {
     set_canonical_cookie_calls_.emplace_back(
-        cookie, source_scheme, modify_http_only, std::move(callback));
+        cookie, secure_source, modify_http_only, std::move(callback));
   }
 
   void DeleteCookies(network::mojom::CookieDeletionFilterPtr filter,
@@ -105,10 +105,8 @@ class FakeCookieManager : public network::TestCookieManager {
   }
 
  private:
-  std::vector<std::tuple<net::CanonicalCookie,
-                         std::string,
-                         bool,
-                         SetCanonicalCookieCallback>>
+  std::vector<
+      std::tuple<net::CanonicalCookie, bool, bool, SetCanonicalCookieCallback>>
       set_canonical_cookie_calls_;
   std::vector<
       std::pair<network::mojom::CookieDeletionFilterPtr, DeleteCookiesCallback>>
@@ -208,8 +206,7 @@ class AndroidSmsAppSetupControllerImplTest : public testing::Test {
 
     fake_cookie_manager_->InvokePendingSetCanonicalCookieCallback(
         "default_to_persist" /* expected_cookie_name */,
-        "true" /* expected_cookie_value */,
-        "https" /* expected_source_scheme */,
+        "true" /* expected_cookie_value */, true /* expected_secure_source */,
         false /* expected_modify_http_only */, true /* success */);
 
     fake_cookie_manager_->InvokePendingDeleteCookiesCallback(
@@ -281,7 +278,7 @@ class AndroidSmsAppSetupControllerImplTest : public testing::Test {
       fake_cookie_manager_->InvokePendingSetCanonicalCookieCallback(
           "cros_migrated_to" /* expected_cookie_name */,
           migrated_to_app_url.GetContent() /* expected_cookie_value */,
-          "https" /* expected_source_scheme */,
+          true /* expected_secure_source */,
           false /* expected_modify_http_only */, true /* success */);
 
       fake_cookie_manager_->InvokePendingDeleteCookiesCallback(

chrome/browser/chromeos/login/profile_auth_data.cc

@@ -81,7 +81,7 @@ void ImportCookies(base::RepeatingClosure completion_callback,
     // another store, they have already gone through the strict secure check.
     DCHECK(cookie.IsCanonical());
     cookie_manager->SetCanonicalCookie(
-        cookie, "https", true /*modify_http_only*/,
+        cookie, true /*secure_source*/, true /*modify_http_only*/,
         base::BindOnce(&OnCookieSet, cookie_completion_callback));
   }
 }

chrome/browser/chromeos/login/profile_auth_data_unittest.cc

@@ -187,21 +187,21 @@ void ProfileAuthDataTest::PopulateBrowserContext(
           kSAMLIdPCookieDomainWithWildcard, std::string(), base::Time(),
           base::Time(), base::Time(), true, false,
           net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT),
-      "https", true /*modify_http_only*/, base::DoNothing());
+      true /*secure_source*/, true /*modify_http_only*/, base::DoNothing());
 
   cookies->SetCanonicalCookie(
       *net::CanonicalCookie::CreateSanitizedCookie(
           GURL(kSAMLIdPCookieURL), kCookieName, cookie_value, std::string(),
           std::string(), base::Time(), base::Time(), base::Time(), true, false,
           net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT),
-      "https", true /*modify_http_only*/, base::DoNothing());
+      true /*secure_source*/, true /*modify_http_only*/, base::DoNothing());
 
   cookies->SetCanonicalCookie(
       *net::CanonicalCookie::CreateSanitizedCookie(
           GURL(kGAIACookieURL), kCookieName, cookie_value, std::string(),
           std::string(), base::Time(), base::Time(), base::Time(), true, false,
           net::CookieSameSite::DEFAULT_MODE, net::COOKIE_PRIORITY_DEFAULT),
-      "https", true /*modify_http_only*/, base::DoNothing());
+      true /*secure_source*/, true /*modify_http_only*/, base::DoNothing());
 }
 
 net::URLRequestContext* ProfileAuthDataTest::GetRequestContext(

chrome/browser/chromeos/login/webview_login_browsertest.cc

@@ -90,7 +90,7 @@ void InjectCookie(content::StoragePartition* storage_partition) {
                            "/", base::Time(), base::Time(), base::Time(), false,
                            false, net::CookieSameSite::NO_RESTRICTION,
                            net::COOKIE_PRIORITY_MEDIUM),
-      "http", false,
+      false, false,
       base::Bind(&InjectCookieDoneCallback, run_loop.QuitClosure()));
   run_loop.Run();
 }

chrome/browser/extensions/api/browsing_data/browsing_data_test.cc

@@ -70,7 +70,7 @@ bool SetGaiaCookieForProfile(Profile* profile) {
       content::BrowserContext::GetDefaultStoragePartition(profile)
           ->GetCookieManagerForBrowserProcess();
   cookie_manager->SetCanonicalCookie(
-      cookie, google_url.scheme(), true,
+      cookie, true, true,
       mojo::WrapCallbackWithDefaultInvokeIfNotRun(std::move(callback), false));
   loop.Run();
   return success;

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

@@ -369,7 +369,7 @@ ExtensionFunction::ResponseAction CookiesSetFunction::Run() {
   // plus FIFO ordering on the cookie_manager_ pipe means that no
   // other extension function will affect the get result.
   cookie_manager->SetCanonicalCookie(
-      *cc, url_.scheme(), true /*modify_http_only*/,
+      *cc, url_.SchemeIsCryptographic(), true /*modify_http_only*/,
       base::BindOnce(&CookiesSetFunction::SetCanonicalCookieCallback, this));
   cookies_helpers::GetCookieListFromManager(
       cookie_manager, url_,

chrome/browser/extensions/extension_service_unittest.cc

@@ -4992,7 +4992,7 @@ TEST_F(ExtensionServiceTest, ClearAppData) {
     bool set_result = false;
     base::RunLoop run_loop;
     cookie_manager_ptr->SetCanonicalCookie(
-        *cc.get(), origin1.scheme(), true /* modify_http_only */,
+        *cc.get(), origin1.SchemeIsCryptographic(), true /* modify_http_only */,
         base::BindOnce(&SetCookieSaveData, &set_result,
                        run_loop.QuitClosure()));
     run_loop.Run();

chrome/browser/net/chrome_network_service_browsertest.cc

@@ -48,7 +48,7 @@ void SetCookie(const network::mojom::CookieManagerPtr& cookie_manager) {
                               net::COOKIE_PRIORITY_DEFAULT);
   base::RunLoop run_loop;
   cookie_manager->SetCanonicalCookie(
-      cookie, "http", false,
+      cookie, false, false,
       base::BindLambdaForTesting([&](bool success) { run_loop.Quit(); }));
   run_loop.Run();
 }

chrome/browser/profile_resetter/profile_resetter_browsertest.cc

@@ -93,7 +93,7 @@ void RemoveCookieTester::AddCookie(const std::string& host,
                            base::Time(), false, false,
                            net::CookieSameSite::NO_RESTRICTION,
                            net::COOKIE_PRIORITY_MEDIUM),
-      "http", true /* modify_http_only */,
+      false /* secure_source */, true /* modify_http_only */,
       base::BindOnce(&RemoveCookieTester::SetCanonicalCookieCallback,
                      base::Unretained(this)));
   BlockUntilNotified();

chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.cc

@@ -379,7 +379,8 @@ void GaiaScreenHandler::LoadGaiaWithPartition(
       net::CookieOptions()));
 
   partition->GetCookieManagerForBrowserProcess()->SetCanonicalCookie(
-      *cc.get(), "https", true /* modify_http_only */, std::move(callback));
+      *cc.get(), true /* secure_source */, true /* modify_http_only */,
+      std::move(callback));
 }
 
 void GaiaScreenHandler::OnSetCookieForLoadGaiaWithPartition(

components/signin/core/browser/gaia_cookie_manager_service.cc

@@ -1171,7 +1171,7 @@ void GaiaCookieManagerService::StartSettingCookies(
           &GaiaCookieManagerService::OnCookieSet,
           weak_ptr_factory_.GetWeakPtr(), cookie.Name(), cookie.Domain());
       cookie_manager->SetCanonicalCookie(
-          cookie, "https", true,
+          cookie, true, true,
           mojo::WrapCallbackWithDefaultInvokeIfNotRun(std::move(callback),
                                                       false));
     } else {

content/browser/browsing_data/clear_site_data_handler_browsertest.cc

@@ -228,7 +228,7 @@ class ClearSiteDataHandlerBrowserTest : public ContentBrowserTest {
 
     base::RunLoop run_loop;
     cookie_manager->SetCanonicalCookie(
-        *cookie, url.scheme(), false /* modify_http_only */,
+        *cookie, true /* secure_source */, false /* modify_http_only */,
         base::BindOnce(&ClearSiteDataHandlerBrowserTest::AddCookieCallback,
                        run_loop.QuitClosure()));
     run_loop.Run();

content/browser/cookie_store/cookie_store_manager_unittest.cc

@@ -319,7 +319,7 @@ class CookieStoreManagerTest
     base::RunLoop run_loop;
     bool success = false;
     cookie_manager_->SetCanonicalCookie(
-        cookie, "https", /* can_modify_httponly = */ true,
+        cookie, /* secure_source = */ true, /* can_modify_httponly = */ true,
         base::BindOnce(
             [](base::RunLoop* run_loop, bool* success, bool service_success) {
               *success = success;

content/browser/devtools/devtools_url_interceptor_request_job.cc

@@ -1080,7 +1080,7 @@ void DevToolsURLInterceptorRequestJob::ProcessInterceptionResponse(
 
       auto* store = request_details_.url_request_context->cookie_store();
       store->SetCanonicalCookieAsync(
-          std::move(cookie), request_details_.url.scheme(),
+          std::move(cookie), request_details_.url.SchemeIsCryptographic(),
           !options.exclude_httponly(), net::CookieStore::SetCookiesCallback());
     }
 

content/browser/devtools/devtools_url_loader_interceptor.cc

@@ -1060,9 +1060,7 @@ void InterceptionJob::ProcessSetCookies(const net::HttpResponseHeaders& headers,
       [](base::RepeatingClosure closure, bool) { closure.Run(); },
       base::BarrierClosure(cookies.size(), std::move(callback)));
   for (auto& cookie : cookies) {
-    cookie_manager_->SetCanonicalCookie(
-        *cookie, create_loader_params_->request.url.scheme(), true,
-        on_cookie_set);
+    cookie_manager_->SetCanonicalCookie(*cookie, true, true, on_cookie_set);
   }
 }
 

content/browser/devtools/protocol/network_handler.cc

@@ -459,7 +459,7 @@ void SetCookieOnIO(
       context_getter->GetURLRequestContext();
 
   request_context->cookie_store()->SetCanonicalCookieAsync(
-      std::move(cookie), "https" /* source_scheme */, true /*modify_http_only*/,
+      std::move(cookie), true /* secure_source */, true /*modify_http_only*/,
       std::move(callback));
 }
 
@@ -1249,7 +1249,7 @@ void NetworkHandler::SetCookie(const std::string& name,
   }
 
   storage_partition_->GetCookieManagerForBrowserProcess()->SetCanonicalCookie(
-      *cookie, "https", true /* modify_http_only */,
+      *cookie, true /* secure_source */, true /* modify_http_only */,
       base::BindOnce(&SetCookieCallback::sendSuccess, std::move(callback)));
 }
 
@@ -1296,7 +1296,7 @@ void NetworkHandler::SetCookies(
       storage_partition_->GetCookieManagerForBrowserProcess();
   for (const auto& cookie : net_cookies) {
     cookie_manager->SetCanonicalCookie(
-        *cookie, "https", true,
+        *cookie, true, true,
         base::BindOnce(
             [](base::RepeatingClosure callback, bool) { callback.Run(); },
             barrier_closure));