Remove URLRequest::GetResponseCookies and URLRequestJob::GetResponseCookies.

sync/internal_api/http_bridge_unittest.cc

 // Copyright 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.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bit_cast.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 139 matching lines @@
     // as if it completed.
     test_->GetIOThreadLoop()->PostTask(FROM_HERE,
         base::Bind(&ShuntedHttpBridge::CallOnURLFetchComplete, this));
   }
 
  private:
   ~ShuntedHttpBridge() override {}
 
   void CallOnURLFetchComplete() {
     ASSERT_TRUE(base::MessageLoop::current() == test_->GetIOThreadLoop());
-    // We return no cookies and a dummy content response.
-    net::ResponseCookies cookies;
-
+    // We return a dummy content response.
     std::string response_content = "success!";
     net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), NULL);
     scoped_refptr<net::HttpResponseHeaders> response_headers(
         new net::HttpResponseHeaders(""));
     fetcher.set_response_code(200);
-    fetcher.set_cookies(cookies);
     fetcher.SetResponseString(response_content);
     fetcher.set_response_headers(response_headers);
     OnURLFetchComplete(&fetcher);
   }
   MAYBE_SyncHttpBridgeTest* test_;
   bool never_finishes_;
 };
 
 void MAYBE_SyncHttpBridgeTest::RunSyncThreadBridgeUseTest(
     base::WaitableEvent* signal_when_created,
@@ skipping 249 matching lines @@
       FROM_HERE,
       base::Bind(&base::WaitableEvent::Wait, base::Unretained(&io_waiter))));
 
   signal_when_created.Wait();  // Wait till we have a bridge to abort.
   ASSERT_TRUE(bridge_for_race_test());
 
   // Schedule the fetch completion callback (but don't run it yet). Don't take
   // a reference to the bridge to mimic URLFetcher's handling of the delegate.
   net::URLFetcherDelegate* delegate =
       static_cast<net::URLFetcherDelegate*>(bridge_for_race_test());
-  net::ResponseCookies cookies;
   std::string response_content = "success!";
   net::TestURLFetcher fetcher(0, GURL("http://www.google.com"), NULL);
   fetcher.set_response_code(200);
-  fetcher.set_cookies(cookies);
   fetcher.SetResponseString(response_content);
   ASSERT_TRUE(io_thread()->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&net::URLFetcherDelegate::OnURLFetchComplete,
           base::Unretained(delegate), &fetcher)));
 
   // Abort the fetch. This should be smart enough to handle the case where
   // the bridge is destroyed before the callback scheduled above completes.
   bridge_for_race_test()->Abort();
 
@@ skipping 123 matching lines @@
 
   // Sync thread: Finally run the posted task, only to find that our
   // HttpBridgeFactory has been neutered.  Should not crash.
   factory->Init("TestUserAgent", BindToTrackerCallback());
 
   // At this point, attempting to use the factory would trigger a crash.  Both
   // this test and the real world code should make sure this never happens.
 }
 
 }  // namespace syncer