Clang format slam.

net/cookies/cookie_store_unittest.h

 // 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.
 
 #ifndef NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 #define NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 73 matching lines @@
   // Helper methods for the asynchronous Cookie Store API that call the
   // asynchronous method and then pump the loop until the callback is invoked,
   // finally returning the value.
 
   std::string GetCookies(CookieStore* cs, const GURL& url) {
     DCHECK(cs);
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
     StringResultCookieCallback callback;
-    cs->GetCookiesWithOptionsAsync(
-        url, options,
-        base::Bind(&StringResultCookieCallback::Run,
-                   base::Unretained(&callback)));
+    cs->GetCookiesWithOptionsAsync(url,
+                                   options,
+                                   base::Bind(&StringResultCookieCallback::Run,
+                                              base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   std::string GetCookiesWithOptions(CookieStore* cs,
                                     const GURL& url,
                                     const CookieOptions& options) {
     DCHECK(cs);
     StringResultCookieCallback callback;
-    cs->GetCookiesWithOptionsAsync(
-        url, options, base::Bind(&StringResultCookieCallback::Run,
-                                 base::Unretained(&callback)));
+    cs->GetCookiesWithOptionsAsync(url,
+                                   options,
+                                   base::Bind(&StringResultCookieCallback::Run,
+                                              base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   bool SetCookieWithOptions(CookieStore* cs,
                             const GURL& url,
                             const std::string& cookie_line,
                             const CookieOptions& options) {
     DCHECK(cs);
     ResultSavingCookieCallback<bool> callback;
     cs->SetCookieWithOptionsAsync(
-        url, cookie_line, options,
-        base::Bind(
-            &ResultSavingCookieCallback<bool>::Run,
-            base::Unretained(&callback)));
+        url,
+        cookie_line,
+        options,
+        base::Bind(&ResultSavingCookieCallback<bool>::Run,
+                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   bool SetCookieWithServerTime(CookieStore* cs,
                                const GURL& url,
                                const std::string& cookie_line,
                                const base::Time& server_time) {
     CookieOptions options;
@@ skipping 11 matching lines @@
       options.set_include_httponly();
     return SetCookieWithOptions(cs, url, cookie_line, options);
   }
 
   void DeleteCookie(CookieStore* cs,
                     const GURL& url,
                     const std::string& cookie_name) {
     DCHECK(cs);
     NoResultCookieCallback callback;
     cs->DeleteCookieAsync(
-        url, cookie_name,
+        url,
+        cookie_name,
         base::Bind(&NoResultCookieCallback::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
   }
 
   int DeleteCreatedBetween(CookieStore* cs,
-                            const base::Time& delete_begin,
-                            const base::Time& delete_end) {
+                           const base::Time& delete_begin,
+                           const base::Time& delete_end) {
     DCHECK(cs);
     ResultSavingCookieCallback<int> callback;
     cs->DeleteAllCreatedBetweenAsync(
-        delete_begin, delete_end,
-        base::Bind(
-            &ResultSavingCookieCallback<int>::Run,
-            base::Unretained(&callback)));
+        delete_begin,
+        delete_end,
+        base::Bind(&ResultSavingCookieCallback<int>::Run,
+                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   int DeleteAllCreatedBetweenForHost(CookieStore* cs,
                                      const base::Time delete_begin,
                                      const base::Time delete_end,
                                      const GURL& url) {
     DCHECK(cs);
     ResultSavingCookieCallback<int> callback;
     cs->DeleteAllCreatedBetweenForHostAsync(
-        delete_begin, delete_end, url,
-        base::Bind(
-            &ResultSavingCookieCallback<int>::Run,
-            base::Unretained(&callback)));
+        delete_begin,
+        delete_end,
+        url,
+        base::Bind(&ResultSavingCookieCallback<int>::Run,
+                   base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   int DeleteSessionCookies(CookieStore* cs) {
     DCHECK(cs);
     ResultSavingCookieCallback<int> callback;
-    cs->DeleteSessionCookiesAsync(
-        base::Bind(
-            &ResultSavingCookieCallback<int>::Run,
-            base::Unretained(&callback)));
+    cs->DeleteSessionCookiesAsync(base::Bind(
+        &ResultSavingCookieCallback<int>::Run, base::Unretained(&callback)));
     RunFor(kTimeout);
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   void RunFor(int ms) {
     // Runs the test thread message loop for up to |ms| milliseconds.
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&base::MessageLoop::Quit, weak_factory_->GetWeakPtr()),
@@ skipping 10 matching lines @@
   void MatchCookieLines(const std::string& line1, const std::string& line2) {
     EXPECT_EQ(TokenizeCookieLine(line1), TokenizeCookieLine(line2));
   }
 
   // Check the cookie line by polling until equality or a timeout is reached.
   void MatchCookieLineWithTimeout(CookieStore* cs,
                                   const GURL& url,
                                   const std::string& line) {
     std::string cookies = GetCookies(cs, url);
     bool matched = (TokenizeCookieLine(line) == TokenizeCookieLine(cookies));
-    base::Time polling_end_date = base::Time::Now() +
+    base::Time polling_end_date =
+        base::Time::Now() +
         base::TimeDelta::FromMilliseconds(
             CookieStoreTestTraits::creation_time_granularity_in_ms);
 
-    while (!matched &&  base::Time::Now() <= polling_end_date) {
+    while (!matched && base::Time::Now() <= polling_end_date) {
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
       cookies = GetCookies(cs, url);
       matched = (TokenizeCookieLine(line) == TokenizeCookieLine(cookies));
     }
 
-    EXPECT_TRUE(matched) << "\"" << cookies
-                         << "\" does not match \"" << line << "\"";
+    EXPECT_TRUE(matched) << "\"" << cookies << "\" does not match \"" << line
+                         << "\"";
   }
 
   GURL url_google_;
   GURL url_google_secure_;
   GURL url_google_foo_;
   GURL url_google_bar_;
 
   scoped_ptr<base::WeakPtrFactory<base::MessageLoop> > weak_factory_;
   scoped_ptr<base::MessageLoop> message_loop_;
 
  private:
   // Returns a set of strings of type "name=value". Fails in case of duplicate.
   std::set<std::string> TokenizeCookieLine(const std::string& line) {
     std::set<std::string> tokens;
     base::StringTokenizer tokenizer(line, " ;");
     while (tokenizer.GetNext())
       EXPECT_TRUE(tokens.insert(tokenizer.token()).second);
     return tokens;
   }
 };
 
 TYPED_TEST_CASE_P(CookieStoreTest);
 
 TYPED_TEST_P(CookieStoreTest, TypeTest) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   EXPECT_EQ(cs->GetCookieMonster(),
-            (TypeParam::is_cookie_monster) ?
-                static_cast<CookieMonster*>(cs.get()) : NULL);
+            (TypeParam::is_cookie_monster)
+                ? static_cast<CookieMonster*>(cs.get())
+                : NULL);
 }
 
 TYPED_TEST_P(CookieStoreTest, DomainTest) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
   this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   EXPECT_TRUE(this->SetCookie(
       cs.get(), this->url_google_, "C=D; domain=.google.izzle"));
   this->MatchCookieLines("A=B; C=D",
                          this->GetCookies(cs.get(), this->url_google_));
@@ skipping 158 matching lines @@
         "a=1", this->GetCookies(cs.get(), GURL("http://sub.www.google.com")));
     this->MatchCookieLines(
         std::string(),
         this->GetCookies(cs.get(), GURL("http://something-else.com")));
   }
 }
 
 // Test that the domain specified in cookie string is treated case-insensitive
 // http://b/issue?id=896475.
 TYPED_TEST_P(CookieStoreTest, CaseInsensitiveDomainTest) {
-    scoped_refptr<CookieStore> cs(this->GetCookieStore());
+  scoped_refptr<CookieStore> cs(this->GetCookieStore());
   GURL url("http://www.google.com");
   EXPECT_TRUE(this->SetCookie(cs.get(), url, "a=1; domain=.GOOGLE.COM"));
   EXPECT_TRUE(this->SetCookie(cs.get(), url, "b=2; domain=.wWw.gOOgLE.coM"));
   this->MatchCookieLines("a=1; b=2", this->GetCookies(cs.get(), url));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestIpAddress) {
   GURL url_ip("http://1.2.3.4/weee");
   {
     scoped_refptr<CookieStore> cs(this->GetCookieStore());
@@ skipping 284 matching lines @@
                          this->GetCookies(cs.get(), this->url_google_));
 
   // Create a persistent cookie.
   EXPECT_TRUE(this->SetCookie(
       cs.get(),
       this->url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   // Check that it is not deleted with significant enough clock skew.
   base::Time server_time;
-  EXPECT_TRUE(base::Time::FromString("Sun, 17-Apr-1977 22:50:13 GMT",
-                                     &server_time));
+  EXPECT_TRUE(
+      base::Time::FromString("Sun, 17-Apr-1977 22:50:13 GMT", &server_time));
   EXPECT_TRUE(this->SetCookieWithServerTime(
       cs.get(),
       this->url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT",
       server_time));
   this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
 
   // Create a persistent cookie.
   EXPECT_TRUE(this->SetCookie(
       cs.get(),
       this->url_google_,
       std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-22 22:50:13 GMT"));
   this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   // Delete it via Expires, with a unix epoch of 0.
   EXPECT_TRUE(this->SetCookie(cs.get(),
                               this->url_google_,
                               std::string(kValidCookieLine) +
                                   "; expires=Thu, 1-Jan-1970 00:00:00 GMT"));
   this->MatchCookieLines(std::string(),
                          this->GetCookies(cs.get(), this->url_google_));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
-  const base::Time last_month = base::Time::Now() -
-                                base::TimeDelta::FromDays(30);
-  const base::Time last_minute = base::Time::Now() -
-                                 base::TimeDelta::FromMinutes(1);
-  const base::Time next_minute = base::Time::Now() +
-                                 base::TimeDelta::FromMinutes(1);
-  const base::Time next_month = base::Time::Now() +
-                                base::TimeDelta::FromDays(30);
+  const base::Time last_month =
+      base::Time::Now() - base::TimeDelta::FromDays(30);
+  const base::Time last_minute =
+      base::Time::Now() - base::TimeDelta::FromMinutes(1);
+  const base::Time next_minute =
+      base::Time::Now() + base::TimeDelta::FromMinutes(1);
+  const base::Time next_month =
+      base::Time::Now() + base::TimeDelta::FromDays(30);
 
   // Add a cookie.
   EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
   // Check that the cookie is in the store.
   this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
 
   // Remove cookies in empty intervals.
   EXPECT_EQ(0, this->DeleteCreatedBetween(cs.get(), last_month, last_minute));
   EXPECT_EQ(0, this->DeleteCreatedBetween(cs.get(), next_minute, next_month));
   // Check that the cookie is still there.
@@ skipping 24 matching lines @@
 
   // These 3 cookies match the time range and host.
   EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
   EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "C=D"));
   EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "Y=Z"));
 
   // This cookie does not match host.
   EXPECT_TRUE(this->SetCookie(cs.get(), url_not_google, "E=F"));
 
   // Delete cookies.
-  EXPECT_EQ(
-      3,  // Deletes A=B, C=D, Y=Z
-      this->DeleteAllCreatedBetweenForHost(
-          cs.get(), now, base::Time::Max(), this->url_google_));
+  EXPECT_EQ(3,  // Deletes A=B, C=D, Y=Z
+            this->DeleteAllCreatedBetweenForHost(
+                cs.get(), now, base::Time::Max(), this->url_google_));
 }
 
 TYPED_TEST_P(CookieStoreTest, TestSecure) {
-    scoped_refptr<CookieStore> cs(this->GetCookieStore());
+  scoped_refptr<CookieStore> cs(this->GetCookieStore());
 
-    EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
-    this->MatchCookieLines("A=B",
-                           this->GetCookies(cs.get(), this->url_google_));
-    this->MatchCookieLines(
-        "A=B", this->GetCookies(cs.get(), this->url_google_secure_));
+  EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
+  this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
+  this->MatchCookieLines("A=B",
+                         this->GetCookies(cs.get(), this->url_google_secure_));
 
   EXPECT_TRUE(
       this->SetCookie(cs.get(), this->url_google_secure_, "A=B; secure"));
   // The secure should overwrite the non-secure.
   this->MatchCookieLines(std::string(),
                          this->GetCookies(cs.get(), this->url_google_));
   this->MatchCookieLines("A=B",
                          this->GetCookies(cs.get(), this->url_google_secure_));
 
   EXPECT_TRUE(
@@ skipping 160 matching lines @@
                            HttpOnlyTest,
                            TestCookieDeletion,
                            TestDeleteAllCreatedBetween,
                            TestDeleteAllCreatedBetweenForHost,
                            TestSecure,
                            NetUtilCookieTest,
                            OverwritePersistentCookie,
                            CookieOrdering,
                            DeleteSessionCookie);
 
-template<class CookieStoreTestTraits>
-class MultiThreadedCookieStoreTest :
-    public CookieStoreTest<CookieStoreTestTraits> {
+template <class CookieStoreTestTraits>
+class MultiThreadedCookieStoreTest
+    : public CookieStoreTest<CookieStoreTestTraits> {
  public:
   MultiThreadedCookieStoreTest() : other_thread_("CMTthread") {}
 
   // Helper methods for calling the asynchronous CookieStore methods
   // from a different thread.
 
   void GetCookiesTask(CookieStore* cs,
                       const GURL& url,
                       StringResultCookieCallback* callback) {
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
-    cs->GetCookiesWithOptionsAsync(
-        url, options,
-        base::Bind(&StringResultCookieCallback::Run,
-                   base::Unretained(callback)));
+    cs->GetCookiesWithOptionsAsync(url,
+                                   options,
+                                   base::Bind(&StringResultCookieCallback::Run,
+                                              base::Unretained(callback)));
   }
 
   void GetCookiesWithOptionsTask(CookieStore* cs,
                                  const GURL& url,
                                  const CookieOptions& options,
                                  StringResultCookieCallback* callback) {
-    cs->GetCookiesWithOptionsAsync(
-        url, options,
-        base::Bind(&StringResultCookieCallback::Run,
-                   base::Unretained(callback)));
+    cs->GetCookiesWithOptionsAsync(url,
+                                   options,
+                                   base::Bind(&StringResultCookieCallback::Run,
+                                              base::Unretained(callback)));
   }
 
   void SetCookieWithOptionsTask(CookieStore* cs,
                                 const GURL& url,
                                 const std::string& cookie_line,
                                 const CookieOptions& options,
                                 ResultSavingCookieCallback<bool>* callback) {
     cs->SetCookieWithOptionsAsync(
-        url, cookie_line, options,
-        base::Bind(
-            &ResultSavingCookieCallback<bool>::Run,
-            base::Unretained(callback)));
+        url,
+        cookie_line,
+        options,
+        base::Bind(&ResultSavingCookieCallback<bool>::Run,
+                   base::Unretained(callback)));
   }
 
   void DeleteCookieTask(CookieStore* cs,
                         const GURL& url,
                         const std::string& cookie_name,
                         NoResultCookieCallback* callback) {
     cs->DeleteCookieAsync(
-        url, cookie_name,
+        url,
+        cookie_name,
         base::Bind(&NoResultCookieCallback::Run, base::Unretained(callback)));
   }
 
-    void DeleteSessionCookiesTask(CookieStore* cs,
-                                  ResultSavingCookieCallback<int>* callback) {
-    cs->DeleteSessionCookiesAsync(
-        base::Bind(
-            &ResultSavingCookieCallback<int>::Run,
-            base::Unretained(callback)));
+  void DeleteSessionCookiesTask(CookieStore* cs,
+                                ResultSavingCookieCallback<int>* callback) {
+    cs->DeleteSessionCookiesAsync(base::Bind(
+        &ResultSavingCookieCallback<int>::Run, base::Unretained(callback)));
   }
 
  protected:
   void RunOnOtherThread(const base::Closure& task) {
     other_thread_.Start();
     other_thread_.message_loop()->PostTask(FROM_HERE, task);
     CookieStoreTest<CookieStoreTestTraits>::RunFor(kTimeout);
     other_thread_.Stop();
   }
 
   Thread other_thread_;
 };
 
 TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest);
 
 // TODO(ycxiao): Eventually, we will need to create a separate thread, create
 // the cookie store on that thread (or at least its store, i.e., the DB
 // thread).
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookies) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
   this->MatchCookieLines("A=B", this->GetCookies(cs.get(), this->url_google_));
   StringResultCookieCallback callback(&this->other_thread_);
-  base::Closure task = base::Bind(
-      &net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesTask,
-      base::Unretained(this),
-      cs, this->url_google_, &callback);
+  base::Closure task =
+      base::Bind(&net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesTask,
+                 base::Unretained(this),
+                 cs,
+                 this->url_google_,
+                 &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("A=B", callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookiesWithOptions) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookie(cs.get(), this->url_google_, "A=B"));
   this->MatchCookieLines(
       "A=B", this->GetCookiesWithOptions(cs.get(), this->url_google_, options));
   StringResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::GetCookiesWithOptionsTask,
       base::Unretained(this),
-      cs, this->url_google_, options, &callback);
+      cs,
+      this->url_google_,
+      options,
+      &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("A=B", callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckSetCookieWithOptions) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(
       this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
   ResultSavingCookieCallback<bool> callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::SetCookieWithOptionsTask,
       base::Unretained(this),
-      cs, this->url_google_, "A=B", options, &callback);
+      cs,
+      this->url_google_,
+      "A=B",
+      options,
+      &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteCookie) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(
       this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
   this->DeleteCookie(cs.get(), this->url_google_, "A");
   EXPECT_TRUE(
       this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
   NoResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteCookieTask,
       base::Unretained(this),
-      cs, this->url_google_, "A", &callback);
+      cs,
+      this->url_google_,
+      "A",
+      &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteSessionCookies) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(
       this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
   EXPECT_TRUE(
       this->SetCookieWithOptions(cs.get(),
                                  this->url_google_,
                                  "B=C; expires=Mon, 18-Apr-22 22:50:13 GMT",
                                  options));
   EXPECT_EQ(1, this->DeleteSessionCookies(cs.get()));
   EXPECT_EQ(0, this->DeleteSessionCookies(cs.get()));
   EXPECT_TRUE(
       this->SetCookieWithOptions(cs.get(), this->url_google_, "A=B", options));
   ResultSavingCookieCallback<int> callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &net::MultiThreadedCookieStoreTest<TypeParam>::DeleteSessionCookiesTask,
       base::Unretained(this),
-      cs, &callback);
+      cs,
+      &callback);
   this->RunOnOtherThread(task);
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1, callback.result());
 }
 
 REGISTER_TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest,
                            ThreadCheckGetCookies,
                            ThreadCheckGetCookiesWithOptions,
                            ThreadCheckSetCookieWithOptions,
                            ThreadCheckDeleteCookie,
                            ThreadCheckDeleteSessionCookies);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_STORE_UNITTEST_H_