Bug 1631523 - Remove unused params in nsICookieService methods - getCookieStringFromHttp without first URI, r=dimi
authorAndrea Marchesini <amarchesini@mozilla.com>
Mon, 20 Apr 2020 18:57:04 +0000
changeset 524924 b12cf9923d6fdef1db56206da96df5891f7b4185
parent 524923 1e35545d94a31125ccb83161dc0959b8e0d3cbc2
child 524925 e6aafdabd8bb29a25544be367ce42023e0d7332c
push id113480
push useramarchesini@mozilla.com
push dateMon, 20 Apr 2020 20:18:12 +0000
treeherderautoland@e6aafdabd8bb [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdimi
bugs1631523
milestone77.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1631523 - Remove unused params in nsICookieService methods - getCookieStringFromHttp without first URI, r=dimi Depends on D71609 Differential Revision: https://phabricator.services.mozilla.com/D71611
netwerk/cookie/CookieService.cpp
netwerk/cookie/CookieServiceChild.cpp
netwerk/cookie/nsICookieService.idl
netwerk/cookie/test/unit/test_bug643051.js
netwerk/cookie/test/unit/test_parser_0001.js
netwerk/cookie/test/unit/test_parser_0019.js
netwerk/protocol/http/HttpBaseChannel.cpp
netwerk/test/TestCookie.cpp
netwerk/test/unit/test_cookies_profile_close.js
--- a/netwerk/cookie/CookieService.cpp
+++ b/netwerk/cookie/CookieService.cpp
@@ -357,18 +357,17 @@ CookieService::GetCookieStringForPrincip
   // then sort by creation time (see bug 236772).
   cookieList.Sort(CompareCookiesForSending());
   ComposeCookieString(cookieList, aCookie);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-CookieService::GetCookieStringFromHttp(nsIURI* aHostURI, nsIURI* /*aFirstURI*/,
-                                       nsIChannel* aChannel,
+CookieService::GetCookieStringFromHttp(nsIURI* aHostURI, nsIChannel* aChannel,
                                        nsACString& aCookieString) {
   NS_ENSURE_ARG(aHostURI);
 
   aCookieString.Truncate();
 
   uint32_t rejectedReason = 0;
   ThirdPartyAnalysisResult result = mThirdPartyUtil->AnalyzeChannel(
       aChannel, false, aHostURI, nullptr, &rejectedReason);
--- a/netwerk/cookie/CookieServiceChild.cpp
+++ b/netwerk/cookie/CookieServiceChild.cpp
@@ -566,17 +566,16 @@ CookieServiceChild::GetCookieStringForPr
     }
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 CookieServiceChild::GetCookieStringFromHttp(nsIURI* /*aHostURI*/,
-                                            nsIURI* /*aFirstURI*/,
                                             nsIChannel* /*aChannel*/,
                                             nsACString& /*aCookieString*/) {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 CookieServiceChild::SetCookieString(nsIURI* aHostURI,
                                     const nsACString& aCookieString,
--- a/netwerk/cookie/nsICookieService.idl
+++ b/netwerk/cookie/nsICookieService.idl
@@ -109,30 +109,26 @@ interface nsICookieService : nsISupports
    * This function is NOT redundant with getCookieString, as the result
    * will be different based on httponly (see bug 178993)
    *
    * @param aURI
    *        The URI of the document for which cookies are being queried.
    *        file:// URIs (i.e. with an empty host) are allowed, but any other
    *        scheme must have a non-empty host. A trailing dot in the host
    *        is acceptable, and will be stripped. This argument must not be null.
-   * @param aFirstURI
-   *        the URI that the user originally typed in or clicked on to initiate
-   *        the load of the document referenced by aURI.
    * @param aChannel
    *        the channel used to load the document.  this parameter should not
    *        be null, otherwise the cookies will not be returned if third-party
    *        cookies have been disabled by the user. (the channel is used
    *        to determine the originating URI of the document; if it is not
    *        provided, the cookies will be assumed third-party.)
    *
    * @return the resulting cookie string
    */
-  ACString getCookieStringFromHttp(in nsIURI aURI, in nsIURI aFirstURI,
-                                   in nsIChannel aChannel);
+  ACString getCookieStringFromHttp(in nsIURI aURI, in nsIChannel aChannel);
 
   /*
    * Set the cookie string associated with the URI.
    *
    * @param aURI
    *        The URI of the document for which cookies are being queried.
    *        file:// URIs (i.e. with an empty host) are allowed, but any other
    *        scheme must have a non-empty host. A trailing dot in the host
--- a/netwerk/cookie/test/unit/test_bug643051.js
+++ b/netwerk/cookie/test/unit/test_bug643051.js
@@ -8,17 +8,17 @@ function run_test() {
   let cs = Cc["@mozilla.org/cookieService;1"].getService(Ci.nsICookieService);
 
   let uri = NetUtil.newURI("http://example.org/");
 
   let set = "foo=bar\nbaz=foo";
   let expected = "foo=bar; baz=foo";
   cs.setCookieStringFromHttp(uri, null, set, null);
 
-  let actual = cs.getCookieStringFromHttp(uri, null, null);
+  let actual = cs.getCookieStringFromHttp(uri, null);
   Assert.equal(actual, expected);
 
   uri = NetUtil.newURI("http://example.com/");
   cs.setCookieString(uri, set, null);
 
   expected = "foo=bar";
   actual = cs.getCookieStringForPrincipal(
     Services.scriptSecurityManager.createContentPrincipal(uri, {})
--- a/netwerk/cookie/test/unit/test_parser_0001.js
+++ b/netwerk/cookie/test/unit/test_parser_0001.js
@@ -14,11 +14,11 @@ function run_test() {
   let cs = Cc["@mozilla.org/cookieService;1"].getService(Ci.nsICookieService);
 
   let uri = NetUtil.newURI("http://example.org/");
 
   let set = "foo=bar";
   cs.setCookieStringFromHttp(uri, null, set, null);
 
   let expected = "foo=bar";
-  let actual = cs.getCookieStringFromHttp(uri, null, null);
+  let actual = cs.getCookieStringFromHttp(uri, null);
   Assert.equal(actual, expected);
 }
--- a/netwerk/cookie/test/unit/test_parser_0019.js
+++ b/netwerk/cookie/test/unit/test_parser_0019.js
@@ -14,11 +14,11 @@ function run_test() {
   let cs = Cc["@mozilla.org/cookieService;1"].getService(Ci.nsICookieService);
 
   let uri = NetUtil.newURI("http://example.org/");
 
   let set = "foo=b;max-age=3600, c=d;path=/";
   cs.setCookieStringFromHttp(uri, null, set, null);
 
   let expected = "foo=b";
-  let actual = cs.getCookieStringFromHttp(uri, null, null);
+  let actual = cs.getCookieStringFromHttp(uri, null);
   Assert.equal(actual, expected);
 }
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -3033,17 +3033,17 @@ void HttpBaseChannel::AddCookiesToReques
     return;
   }
 
   bool useCookieService = (XRE_IsParentProcess());
   nsAutoCString cookie;
   if (useCookieService) {
     nsICookieService* cs = gHttpHandler->GetCookieService();
     if (cs) {
-      cs->GetCookieStringFromHttp(mURI, nullptr, this, cookie);
+      cs->GetCookieStringFromHttp(mURI, this, cookie);
     }
 
     if (cookie.IsEmpty()) {
       cookie = mUserSetCookieHeader;
     } else if (!mUserSetCookieHeader.IsEmpty()) {
       cookie.AppendLiteral("; ");
       cookie.Append(mUserSetCookieHeader);
     }
--- a/netwerk/test/TestCookie.cpp
+++ b/netwerk/test/TestCookie.cpp
@@ -117,24 +117,22 @@ void SetACookieNoHttp(nsICookieService* 
   NS_NewURI(getter_AddRefs(uri), aSpec);
 
   nsresult rv = aCookieService->SetCookieString(
       uri, nsDependentCString(aCookieString), nullptr);
   EXPECT_TRUE(NS_SUCCEEDED(rv));
 }
 
 // The cookie string is returned via aCookie.
-void GetACookie(nsICookieService* aCookieService, const char* aSpec1,
-                const char* aSpec2, nsACString& aCookie) {
-  nsCOMPtr<nsIURI> uri1, uri2;
-  NS_NewURI(getter_AddRefs(uri1), aSpec1);
-  if (aSpec2) NS_NewURI(getter_AddRefs(uri2), aSpec2);
+void GetACookie(nsICookieService* aCookieService, const char* aSpec,
+                nsACString& aCookie) {
+  nsCOMPtr<nsIURI> uri;
+  NS_NewURI(getter_AddRefs(uri), aSpec);
 
-  Unused << aCookieService->GetCookieStringFromHttp(uri1, uri2, nullptr,
-                                                    aCookie);
+  Unused << aCookieService->GetCookieStringFromHttp(uri, nullptr, aCookie);
 }
 
 // The cookie string is returned via aCookie.
 void GetACookieNoHttp(nsICookieService* aCookieService, const char* aSpec,
                       nsACString& aCookie) {
   nsCOMPtr<nsIURI> uri;
   NS_NewURI(getter_AddRefs(uri), aSpec);
 
@@ -230,149 +228,147 @@ TEST(TestCookie, TestCookieMain)
    *    string contains them all, in some order.
    *
    * NOTE: this testsuite is not yet comprehensive or complete, and is
    * somewhat contrived - still under development, and needs improving!
    */
 
   // test some basic variations of the domain & path
   SetACookie(cookieService, "http://www.basic.com", nullptr, "test=basic");
-  GetACookie(cookieService, "http://www.basic.com", nullptr, cookie);
+  GetACookie(cookieService, "http://www.basic.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=basic"));
   GetACookie(cookieService, "http://www.basic.com/testPath/testfile.txt",
-             nullptr, cookie);
+             cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=basic"));
-  GetACookie(cookieService, "http://www.basic.com./", nullptr, cookie);
+  GetACookie(cookieService, "http://www.basic.com./", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
-  GetACookie(cookieService, "http://www.basic.com.", nullptr, cookie);
+  GetACookie(cookieService, "http://www.basic.com.", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   GetACookie(cookieService, "http://www.basic.com./testPath/testfile.txt",
-             nullptr, cookie);
+             cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
-  GetACookie(cookieService, "http://www.basic2.com/", nullptr, cookie);
+  GetACookie(cookieService, "http://www.basic2.com/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://www.basic.com", nullptr,
              "test=basic; max-age=-1");
-  GetACookie(cookieService, "http://www.basic.com/", nullptr, cookie);
+  GetACookie(cookieService, "http://www.basic.com/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // *** domain tests
 
   // test some variations of the domain & path, for different domains of
   // a domain cookie
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=domain.com");
-  GetACookie(cookieService, "http://domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=domain"));
-  GetACookie(cookieService, "http://domain.com.", nullptr, cookie);
+  GetACookie(cookieService, "http://domain.com.", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
-  GetACookie(cookieService, "http://www.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://www.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=domain"));
-  GetACookie(cookieService, "http://foo.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://foo.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=domain"));
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=domain.com; max-age=-1");
-  GetACookie(cookieService, "http://domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=.domain.com");
-  GetACookie(cookieService, "http://domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=domain"));
-  GetACookie(cookieService, "http://www.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://www.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=domain"));
-  GetACookie(cookieService, "http://bah.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://bah.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=domain"));
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=.domain.com; max-age=-1");
-  GetACookie(cookieService, "http://domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=.foo.domain.com");
-  GetACookie(cookieService, "http://foo.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://foo.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=moose.com");
-  GetACookie(cookieService, "http://foo.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://foo.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=domain.com.");
-  GetACookie(cookieService, "http://foo.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://foo.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=..domain.com");
-  GetACookie(cookieService, "http://foo.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://foo.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://www.domain.com", nullptr,
              "test=domain; domain=..domain.com.");
-  GetACookie(cookieService, "http://foo.domain.com", nullptr, cookie);
+  GetACookie(cookieService, "http://foo.domain.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://path.net/path/file", nullptr,
              R"(test=taco; path="/bogus")");
-  GetACookie(cookieService, "http://path.net/path/file", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path/file", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=taco"));
   SetACookie(cookieService, "http://path.net/path/file", nullptr,
              "test=taco; max-age=-1");
-  GetACookie(cookieService, "http://path.net/path/file", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path/file", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // *** path tests
 
   // test some variations of the domain & path, for different paths of
   // a path cookie
   SetACookie(cookieService, "http://path.net/path/file", nullptr,
              "test=path; path=/path");
-  GetACookie(cookieService, "http://path.net/path", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=path"));
-  GetACookie(cookieService, "http://path.net/path/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=path"));
-  GetACookie(cookieService, "http://path.net/path/hithere.foo", nullptr,
-             cookie);
+  GetACookie(cookieService, "http://path.net/path/hithere.foo", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=path"));
-  GetACookie(cookieService, "http://path.net/path?hithere/foo", nullptr,
-             cookie);
+  GetACookie(cookieService, "http://path.net/path?hithere/foo", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=path"));
-  GetACookie(cookieService, "http://path.net/path2", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path2", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
-  GetACookie(cookieService, "http://path.net/path2/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path2/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://path.net/path/file", nullptr,
              "test=path; path=/path; max-age=-1");
-  GetACookie(cookieService, "http://path.net/path/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://path.net/path/file", nullptr,
              "test=path; path=/path/");
-  GetACookie(cookieService, "http://path.net/path", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
-  GetACookie(cookieService, "http://path.net/path/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=path"));
   SetACookie(cookieService, "http://path.net/path/file", nullptr,
              "test=path; path=/path/; max-age=-1");
-  GetACookie(cookieService, "http://path.net/path/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // note that a site can set a cookie for a path it's not on.
   // this is an intentional deviation from spec (see comments in
   // CookieService::CheckPath()), so we test this functionality too
   SetACookie(cookieService, "http://path.net/path/file", nullptr,
              "test=path; path=/foo/");
-  GetACookie(cookieService, "http://path.net/path", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/path", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
-  GetACookie(cookieService, "http://path.net/foo", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/foo", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://path.net/path/file", nullptr,
              "test=path; path=/foo/; max-age=-1");
-  GetACookie(cookieService, "http://path.net/foo/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/foo/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // bug 373228: make sure cookies with paths longer than 1024 bytes,
   // and cookies with paths or names containing tabs, are rejected.
   // the following cookie has a path > 1024 bytes explicitly specified in the
   // cookie
   SetACookie(
       cookieService, "http://path.net/", nullptr,
@@ -406,17 +402,17 @@ TEST(TestCookie, TestCookieMain)
       "567890123456789012345678901234567890123456789012345678901234567890123456"
       "789012345678901234567890123456789012345678901234567890123456789012345678"
       "901234567890123456789012345678901234567890123456789012345678901234567890"
       "123456789012345678901234567890123456789012345678901234567890123456789012"
       "345678901234567890123456789012345678901234567890123456789012345678901234"
       "567890123456789012345678901234567890123456789012345678901234567890123456"
       "789012345678901234567890123456789012345678901234567890123456789012345678"
       "9012345678901234567890",
-      nullptr, cookie);
+      cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   // the following cookie has a path > 1024 bytes implicitly specified by the
   // uri path
   SetACookie(
       cookieService,
       "http://path.net/"
       "123456789012345678901234567890123456789012345678901234567890123456789012"
       "345678901234567890123456789012345678901234567890123456789012345678901234"
@@ -447,175 +443,175 @@ TEST(TestCookie, TestCookieMain)
       "567890123456789012345678901234567890123456789012345678901234567890123456"
       "789012345678901234567890123456789012345678901234567890123456789012345678"
       "901234567890123456789012345678901234567890123456789012345678901234567890"
       "123456789012345678901234567890123456789012345678901234567890123456789012"
       "345678901234567890123456789012345678901234567890123456789012345678901234"
       "567890123456789012345678901234567890123456789012345678901234567890123456"
       "789012345678901234567890123456789012345678901234567890123456789012345678"
       "9012345678901234567890/",
-      nullptr, cookie);
+      cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   // the following cookie includes a tab in the path
   SetACookie(cookieService, "http://path.net/", nullptr,
              "test=path; path=/foo\tbar/");
-  GetACookie(cookieService, "http://path.net/foo\tbar/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/foo\tbar/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   // the following cookie includes a tab in the name
   SetACookie(cookieService, "http://path.net/", nullptr, "test\ttabs=tab");
-  GetACookie(cookieService, "http://path.net/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   // the following cookie includes a tab in the value - allowed
   SetACookie(cookieService, "http://path.net/", nullptr, "test=tab\ttest");
-  GetACookie(cookieService, "http://path.net/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=tab\ttest"));
   SetACookie(cookieService, "http://path.net/", nullptr,
              "test=tab\ttest; max-age=-1");
-  GetACookie(cookieService, "http://path.net/", nullptr, cookie);
+  GetACookie(cookieService, "http://path.net/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // *** expiry & deletion tests
   // XXX add server time str parsing tests here
 
   // test some variations of the expiry time,
   // and test deletion of previously set cookies
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; max-age=-1");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; max-age=0");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; expires=bad");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=expiry"));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; expires=Thu, 10 Apr 1980 16:33:12 GMT");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              R"(test=expiry; expires="Thu, 10 Apr 1980 16:33:12 GMT)");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              R"(test=expiry; expires="Thu, 10 Apr 1980 16:33:12 GMT")");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; max-age=60");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=expiry"));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; max-age=-20");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; max-age=60");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=expiry"));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; expires=Thu, 10 Apr 1980 16:33:12 GMT");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=expiry; max-age=60");
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "newtest=expiry; max-age=60");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "test=expiry"));
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "newtest=expiry"));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "test=differentvalue; max-age=0");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "newtest=expiry"));
   SetACookie(cookieService, "http://expireme.org/", nullptr,
              "newtest=evendifferentvalue; max-age=0");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://foo.expireme.org/", nullptr,
              "test=expiry; domain=.expireme.org; max-age=60");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=expiry"));
   SetACookie(cookieService, "http://bar.expireme.org/", nullptr,
              "test=differentvalue; domain=.expireme.org; max-age=0");
-  GetACookie(cookieService, "http://expireme.org/", nullptr, cookie);
+  GetACookie(cookieService, "http://expireme.org/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   nsAutoCString ServerTime;
   nsAutoCString CookieString;
 
   // *** multiple cookie tests
 
   // test the setting of multiple cookies, and test the order of precedence
   // (a later cookie overwriting an earlier one, in the same header string)
   SetACookie(cookieService, "http://multiple.cookies/", nullptr,
              "test=multiple; domain=.multiple.cookies \n test=different \n "
              "test=same; domain=.multiple.cookies \n newtest=ciao \n "
              "newtest=foo; max-age=-6 \n newtest=reincarnated");
-  GetACookie(cookieService, "http://multiple.cookies/", nullptr, cookie);
+  GetACookie(cookieService, "http://multiple.cookies/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_NOT_CONTAIN, "test=multiple"));
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "test=different"));
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "test=same"));
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_NOT_CONTAIN, "newtest=ciao"));
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_NOT_CONTAIN, "newtest=foo"));
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "newtest=reincarnated"));
   SetACookie(cookieService, "http://multiple.cookies/", nullptr,
              "test=expiry; domain=.multiple.cookies; max-age=0");
-  GetACookie(cookieService, "http://multiple.cookies/", nullptr, cookie);
+  GetACookie(cookieService, "http://multiple.cookies/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_NOT_CONTAIN, "test=same"));
   SetACookie(cookieService, "http://multiple.cookies/", nullptr,
              "\n test=different; max-age=0 \n");
-  GetACookie(cookieService, "http://multiple.cookies/", nullptr, cookie);
+  GetACookie(cookieService, "http://multiple.cookies/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_NOT_CONTAIN, "test=different"));
   SetACookie(cookieService, "http://multiple.cookies/", nullptr,
              "newtest=dead; max-age=0");
-  GetACookie(cookieService, "http://multiple.cookies/", nullptr, cookie);
+  GetACookie(cookieService, "http://multiple.cookies/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // *** parser tests
 
   // test the cookie header parser, under various circumstances.
   SetACookie(cookieService, "http://parser.test/", nullptr,
              "test=parser; domain=.parser.test; ;; ;=; ,,, ===,abc,=; "
              "abracadabra! max-age=20;=;;");
-  GetACookie(cookieService, "http://parser.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://parser.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=parser"));
   SetACookie(cookieService, "http://parser.test/", nullptr,
              "test=parser; domain=.parser.test; max-age=0");
-  GetACookie(cookieService, "http://parser.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://parser.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   SetACookie(cookieService, "http://parser.test/", nullptr,
              "test=\"fubar! = foo;bar\\\";\" parser; domain=.parser.test; "
              "max-age=6\nfive; max-age=2.63,");
-  GetACookie(cookieService, "http://parser.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://parser.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, R"(test="fubar! = foo)"));
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "five"));
   SetACookie(cookieService, "http://parser.test/", nullptr,
              "test=kill; domain=.parser.test; max-age=0 \n five; max-age=0");
-  GetACookie(cookieService, "http://parser.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://parser.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // test the handling of VALUE-only cookies (see bug 169091),
   // i.e. "six" should assume an empty NAME, which allows other VALUE-only
   // cookies to overwrite it
   SetACookie(cookieService, "http://parser.test/", nullptr, "six");
-  GetACookie(cookieService, "http://parser.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://parser.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "six"));
   SetACookie(cookieService, "http://parser.test/", nullptr, "seven");
-  GetACookie(cookieService, "http://parser.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://parser.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "seven"));
   SetACookie(cookieService, "http://parser.test/", nullptr, " =eight");
-  GetACookie(cookieService, "http://parser.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://parser.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "eight"));
   SetACookie(cookieService, "http://parser.test/", nullptr, "test=six");
-  GetACookie(cookieService, "http://parser.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://parser.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "test=six"));
 
   // *** path ordering tests
 
   // test that cookies are returned in path order - longest to shortest.
   // if the header doesn't specify a path, it's taken from the host URI.
   SetACookie(cookieService, "http://multi.path.tests/", nullptr,
              "test1=path; path=/one/two/three");
@@ -625,57 +621,56 @@ TEST(TestCookie, TestCookieMain)
   SetACookie(cookieService, "http://multi.path.tests/one/two/three/four/five/",
              nullptr, "test6=path");
   SetACookie(cookieService,
              "http://multi.path.tests/one/two/three/four/five/six/", nullptr,
              "test7=path; path=");
   SetACookie(cookieService, "http://multi.path.tests/", nullptr,
              "test8=path; path=/");
   GetACookie(cookieService,
-             "http://multi.path.tests/one/two/three/four/five/six/", nullptr,
-             cookie);
+             "http://multi.path.tests/one/two/three/four/five/six/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL,
                           "test7=path; test6=path; test3=path; test1=path; "
                           "test5=path; test4=path; test2=path; test8=path"));
 
   // *** httponly tests
 
   // Since this cookie is NOT set via http, setting it fails
   SetACookieNoHttp(cookieService, "http://httponly.test/",
                    "test=httponly; httponly");
-  GetACookie(cookieService, "http://httponly.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://httponly.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   // Since this cookie is set via http, it can be retrieved
   SetACookie(cookieService, "http://httponly.test/", nullptr,
              "test=httponly; httponly");
-  GetACookie(cookieService, "http://httponly.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://httponly.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=httponly"));
   // ... but not by web content
   GetACookieNoHttp(cookieService, "http://httponly.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   // Non-Http cookies should not replace HttpOnly cookies
   SetACookie(cookieService, "http://httponly.test/", nullptr,
              "test=httponly; httponly");
   SetACookieNoHttp(cookieService, "http://httponly.test/", "test=not-httponly");
-  GetACookie(cookieService, "http://httponly.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://httponly.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=httponly"));
   // ... and, if an HttpOnly cookie already exists, should not be set at all
   GetACookieNoHttp(cookieService, "http://httponly.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   // Non-Http cookies should not delete HttpOnly cookies
   SetACookie(cookieService, "http://httponly.test/", nullptr,
              "test=httponly; httponly");
   SetACookieNoHttp(cookieService, "http://httponly.test/",
                    "test=httponly; max-age=-1");
-  GetACookie(cookieService, "http://httponly.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://httponly.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=httponly"));
   // ... but HttpOnly cookies should
   SetACookie(cookieService, "http://httponly.test/", nullptr,
              "test=httponly; httponly; max-age=-1");
-  GetACookie(cookieService, "http://httponly.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://httponly.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
   // Non-Httponly cookies can replace HttpOnly cookies when set over http
   SetACookie(cookieService, "http://httponly.test/", nullptr,
              "test=httponly; httponly");
   SetACookie(cookieService, "http://httponly.test/", nullptr,
              "test=not-httponly");
   GetACookieNoHttp(cookieService, "http://httponly.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=not-httponly"));
@@ -694,60 +689,60 @@ TEST(TestCookie, TestCookieMain)
   SetACookie(cookieService, "http://prefixed.test/", nullptr,
              "__Secure-test1=test");
   SetACookie(cookieService, "http://prefixed.test/", nullptr,
              "__Secure-test2=test; secure");
   SetACookie(cookieService, "http://prefixed.test/", nullptr,
              "__Host-test1=test");
   SetACookie(cookieService, "http://prefixed.test/", nullptr,
              "__Host-test2=test; secure");
-  GetACookie(cookieService, "http://prefixed.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://prefixed.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // prefixed cookies won't be set without the secure flag
   SetACookie(cookieService, "https://prefixed.test/", nullptr,
              "__Secure-test=test");
   SetACookie(cookieService, "https://prefixed.test/", nullptr,
              "__Host-test=test");
-  GetACookie(cookieService, "https://prefixed.test/", nullptr, cookie);
+  GetACookie(cookieService, "https://prefixed.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // prefixed cookies can be set when done correctly
   SetACookie(cookieService, "https://prefixed.test/", nullptr,
              "__Secure-test=test; secure");
   SetACookie(cookieService, "https://prefixed.test/", nullptr,
              "__Host-test=test; secure");
-  GetACookie(cookieService, "https://prefixed.test/", nullptr, cookie);
+  GetACookie(cookieService, "https://prefixed.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "__Secure-test=test"));
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "__Host-test=test"));
 
   // but when set must not be returned to the host insecurely
-  GetACookie(cookieService, "http://prefixed.test/", nullptr, cookie);
+  GetACookie(cookieService, "http://prefixed.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // Host-prefixed cookies cannot specify a domain
   SetACookie(cookieService, "https://host.prefixed.test/", nullptr,
              "__Host-a=test; secure; domain=prefixed.test");
   SetACookie(cookieService, "https://host.prefixed.test/", nullptr,
              "__Host-b=test; secure; domain=.prefixed.test");
   SetACookie(cookieService, "https://host.prefixed.test/", nullptr,
              "__Host-c=test; secure; domain=host.prefixed.test");
   SetACookie(cookieService, "https://host.prefixed.test/", nullptr,
              "__Host-d=test; secure; domain=.host.prefixed.test");
-  GetACookie(cookieService, "https://host.prefixed.test/", nullptr, cookie);
+  GetACookie(cookieService, "https://host.prefixed.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // Host-prefixed cookies can only have a path of "/"
   SetACookie(cookieService, "https://host.prefixed.test/some/path", nullptr,
              "__Host-e=test; secure");
   SetACookie(cookieService, "https://host.prefixed.test/some/path", nullptr,
              "__Host-f=test; secure; path=/");
   SetACookie(cookieService, "https://host.prefixed.test/some/path", nullptr,
              "__Host-g=test; secure; path=/some");
-  GetACookie(cookieService, "https://host.prefixed.test/", nullptr, cookie);
+  GetACookie(cookieService, "https://host.prefixed.test/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "__Host-f=test"));
 
   // *** leave-secure-alone tests
 
   // testing items 0 & 1 for 3.1 of spec Deprecate modification of ’secure’
   // cookies from non-secure origins
   SetACookie(cookieService, "http://www.security.test/", nullptr,
              "test=non-security; secure");
@@ -855,17 +850,17 @@ TEST(TestCookie, TestCookieMain)
     cookie->GetName(name);
     if (name.EqualsLiteral("test2"))
       expiredCookie = cookie;
     else if (name.EqualsLiteral("test3"))
       newDomainCookie = cookie;
   }
   EXPECT_EQ(cookies.Length(), 3ul);
   // check the httpOnly attribute of the second cookie is honored
-  GetACookie(cookieService, "http://cookiemgr.test/foo/", nullptr, cookie);
+  GetACookie(cookieService, "http://cookiemgr.test/foo/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_CONTAIN, "test2=yes"));
   GetACookieNoHttp(cookieService, "http://cookiemgr.test/foo/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_NOT_CONTAIN, "test2=yes"));
   // check CountCookiesFromHost()
   uint32_t hostCookies = 0;
   EXPECT_TRUE(NS_SUCCEEDED(cookieMgr2->CountCookiesFromHost(
       NS_LITERAL_CSTRING("cookiemgr.test"), &hostCookies)));
   EXPECT_EQ(hostCookies, 2u);
@@ -908,17 +903,17 @@ TEST(TestCookie, TestCookieMain)
     SetACookie(cookieService, "http://creation.ordering.tests/", nullptr,
                name.get());
 
     if (i >= 10) {
       expected += name;
       if (i < 59) expected += NS_LITERAL_CSTRING("; ");
     }
   }
-  GetACookie(cookieService, "http://creation.ordering.tests/", nullptr, cookie);
+  GetACookie(cookieService, "http://creation.ordering.tests/", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, expected.get()));
 
   cookieMgr->RemoveAll();
 
   for (int32_t i = 0; i < 60; ++i) {
     name = NS_LITERAL_CSTRING("test");
     name.AppendInt(i);
     name += NS_LITERAL_CSTRING("=delete_non_security");
@@ -930,17 +925,17 @@ TEST(TestCookie, TestCookieMain)
                  name.get());
     } else {
       // non-security cookies will be removed beside the latest cookie that be
       // created.
       SetACookie(cookieService, "http://creation.ordering.tests/", nullptr,
                  name.get());
     }
   }
-  GetACookie(cookieService, "http://creation.ordering.tests/", nullptr, cookie);
+  GetACookie(cookieService, "http://creation.ordering.tests/", cookie);
 
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   // *** SameSite attribute - parsing and cookie storage tests
   // Clear the cookies
   EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->RemoveAll()));
 
   // None of these cookies will be set because using
@@ -1014,34 +1009,34 @@ TEST(TestCookie, TestCookieMain)
   EXPECT_TRUE(NS_SUCCEEDED(cookieMgr->RemoveAll()));
 
   // please note that the flag aForeign is always set to true using this test
   // setup because no nsIChannel is passed to SetCookieString(). therefore we
   // can only test that no cookies are sent for cross origin requests using
   // same-site cookies.
   SetACookie(cookieService, "http://www.samesite.com", nullptr,
              "test=sameSiteStrictVal; samesite=strict");
-  GetACookie(cookieService, "http://www.notsamesite.com", nullptr, cookie);
+  GetACookie(cookieService, "http://www.notsamesite.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   SetACookie(cookieService, "http://www.samesite.test", nullptr,
              "test=sameSiteLaxVal; samesite=lax");
-  GetACookie(cookieService, "http://www.notsamesite.com", nullptr, cookie);
+  GetACookie(cookieService, "http://www.notsamesite.com", cookie);
   EXPECT_TRUE(CheckResult(cookie.get(), MUST_BE_NULL));
 
   static const char* secureURIs[] = {
       "http://localhost", "http://localhost:1234", "http://127.0.0.1",
       "http://127.0.0.2", "http://127.1.0.1",      "http://[::1]",
       // TODO bug 1220810 "http://xyzzy.localhost"
   };
 
   uint32_t numSecureURIs = sizeof(secureURIs) / sizeof(const char*);
   for (uint32_t i = 0; i < numSecureURIs; ++i) {
     SetACookie(cookieService, secureURIs[i], nullptr, "test=basic; secure");
-    GetACookie(cookieService, secureURIs[i], nullptr, cookie);
+    GetACookie(cookieService, secureURIs[i], cookie);
     EXPECT_TRUE(CheckResult(cookie.get(), MUST_EQUAL, "test=basic"));
   }
 
   // XXX the following are placeholders: add these tests please!
   // *** "noncompliant cookie" tests
   // *** IP address tests
   // *** speed tests
 }
--- a/netwerk/test/unit/test_cookies_profile_close.js
+++ b/netwerk/test/unit/test_cookies_profile_close.js
@@ -41,17 +41,17 @@ function* do_run_test() {
   Assert.ok(cookies.length == 1);
   let cookie = cookies[0];
 
   // Fire 'profile-before-change'.
   do_close_profile();
 
   // Check that the APIs behave appropriately.
   Assert.equal(Services.cookies.getCookieStringForPrincipal(principal), "");
-  Assert.equal(Services.cookies.getCookieStringFromHttp(uri, null, null), "");
+  Assert.equal(Services.cookies.getCookieStringFromHttp(uri, null), "");
   Services.cookies.setCookieString(uri, "oh2=hai", null);
   Services.cookies.setCookieStringFromHttp(uri, null, "oh3=hai", null);
   Assert.equal(Services.cookies.getCookieStringForPrincipal(principal), "");
 
   do_check_throws(function() {
     Services.cookiemgr.removeAll();
   }, Cr.NS_ERROR_NOT_AVAILABLE);