Clang format slam.

net/cookies/cookie_monster_store_test.cc

Index: net/cookies/cookie_monster_store_test.cc
diff --git a/net/cookies/cookie_monster_store_test.cc b/net/cookies/cookie_monster_store_test.cc
index 350a0159b900006be42c0e1f9f964ecc504c47c5..5d566c7b60ac27469c427e64d9cd9f84bda6d74f 100644
--- a/net/cookies/cookie_monster_store_test.cc
+++ b/net/cookies/cookie_monster_store_test.cc
@@ -17,15 +17,14 @@
 namespace net {
 LoadedCallbackTask::LoadedCallbackTask(LoadedCallback loaded_callback,
                                        std::vector<CanonicalCookie*> cookies)
-    : loaded_callback_(loaded_callback),
-      cookies_(cookies) {
+    : loaded_callback_(loaded_callback), cookies_(cookies) {
 }
 
-LoadedCallbackTask::~LoadedCallbackTask() {}
+LoadedCallbackTask::~LoadedCallbackTask() {
+}
 
 MockPersistentCookieStore::MockPersistentCookieStore()
-    : load_return_value_(true),
-      loaded_(false) {
+    : load_return_value_(true), loaded_(false) {
 }
 
 void MockPersistentCookieStore::SetLoadExpectation(
@@ -62,19 +61,17 @@ void MockPersistentCookieStore::LoadCookiesForKey(
 }
 
 void MockPersistentCookieStore::AddCookie(const CanonicalCookie& cookie) {
-  commands_.push_back(
-      CookieStoreCommand(CookieStoreCommand::ADD, cookie));
+  commands_.push_back(CookieStoreCommand(CookieStoreCommand::ADD, cookie));
 }
 
 void MockPersistentCookieStore::UpdateCookieAccessTime(
     const CanonicalCookie& cookie) {
-  commands_.push_back(CookieStoreCommand(
-      CookieStoreCommand::UPDATE_ACCESS_TIME, cookie));
+  commands_.push_back(
+      CookieStoreCommand(CookieStoreCommand::UPDATE_ACCESS_TIME, cookie));
 }
 
 void MockPersistentCookieStore::DeleteCookie(const CanonicalCookie& cookie) {
-  commands_.push_back(
-      CookieStoreCommand(CookieStoreCommand::REMOVE, cookie));
+  commands_.push_back(CookieStoreCommand(CookieStoreCommand::REMOVE, cookie));
 }
 
 void MockPersistentCookieStore::Flush(const base::Closure& callback) {
@@ -85,9 +82,11 @@ void MockPersistentCookieStore::Flush(const base::Closure& callback) {
 void MockPersistentCookieStore::SetForceKeepSessionState() {
 }
 
-MockPersistentCookieStore::~MockPersistentCookieStore() {}
+MockPersistentCookieStore::~MockPersistentCookieStore() {
+}
 
-MockCookieMonsterDelegate::MockCookieMonsterDelegate() {}
+MockCookieMonsterDelegate::MockCookieMonsterDelegate() {
+}
 
 void MockCookieMonsterDelegate::OnCookieChanged(
     const CanonicalCookie& cookie,
@@ -97,12 +96,12 @@ void MockCookieMonsterDelegate::OnCookieChanged(
   changes_.push_back(notification);
 }
 
-MockCookieMonsterDelegate::~MockCookieMonsterDelegate() {}
+MockCookieMonsterDelegate::~MockCookieMonsterDelegate() {
+}
 
 CanonicalCookie BuildCanonicalCookie(const std::string& key,
                                      const std::string& cookie_line,
                                      const base::Time& creation_time) {
-
   // Parse the cookie line.
   ParsedCookie pc(cookie_line);
   EXPECT_TRUE(pc.IsValid());
@@ -112,24 +111,30 @@ CanonicalCookie BuildCanonicalCookie(const std::string& key,
   // functions. Would be nice to export them, and re-use here.
   EXPECT_FALSE(pc.HasMaxAge());
   EXPECT_TRUE(pc.HasPath());
-  base::Time cookie_expires = pc.HasExpires() ?
-      cookie_util::ParseCookieTime(pc.Expires()) : base::Time();
+  base::Time cookie_expires = pc.HasExpires()
+                                  ? cookie_util::ParseCookieTime(pc.Expires())
+                                  : base::Time();
   std::string cookie_path = pc.Path();
 
-  return CanonicalCookie(
-      GURL(), pc.Name(), pc.Value(), key, cookie_path,
-      creation_time, cookie_expires, creation_time,
-      pc.IsSecure(), pc.IsHttpOnly(), pc.Priority());
-}
-
-void AddCookieToList(
-    const std::string& key,
-    const std::string& cookie_line,
-    const base::Time& creation_time,
-    std::vector<CanonicalCookie*>* out_list) {
-  scoped_ptr<CanonicalCookie> cookie(
-      new CanonicalCookie(
-          BuildCanonicalCookie(key, cookie_line, creation_time)));
+  return CanonicalCookie(GURL(),
+                         pc.Name(),
+                         pc.Value(),
+                         key,
+                         cookie_path,
+                         creation_time,
+                         cookie_expires,
+                         creation_time,
+                         pc.IsSecure(),
+                         pc.IsHttpOnly(),
+                         pc.Priority());
+}
+
+void AddCookieToList(const std::string& key,
+                     const std::string& cookie_line,
+                     const base::Time& creation_time,
+                     std::vector<CanonicalCookie*>* out_list) {
+  scoped_ptr<CanonicalCookie> cookie(new CanonicalCookie(
+      BuildCanonicalCookie(key, cookie_line, creation_time)));
 
   out_list->push_back(cookie.release());
 }
@@ -143,7 +148,8 @@ void MockSimplePersistentCookieStore::Load(
   std::vector<CanonicalCookie*> out_cookies;
 
   for (CanonicalCookieMap::const_iterator it = cookies_.begin();
-       it != cookies_.end(); it++)
+       it != cookies_.end();
+       it++)
     out_cookies.push_back(new CanonicalCookie(it->second));
 
   base::MessageLoop::current()->PostTask(
@@ -153,7 +159,8 @@ void MockSimplePersistentCookieStore::Load(
   loaded_ = true;
 }
 
-void MockSimplePersistentCookieStore::LoadCookiesForKey(const std::string& key,
+void MockSimplePersistentCookieStore::LoadCookiesForKey(
+    const std::string& key,
     const LoadedCallback& loaded_callback) {
   if (!loaded_) {
     Load(loaded_callback);
@@ -195,10 +202,9 @@ void MockSimplePersistentCookieStore::Flush(const base::Closure& callback) {
 void MockSimplePersistentCookieStore::SetForceKeepSessionState() {
 }
 
-CookieMonster* CreateMonsterFromStoreForGC(
-    int num_cookies,
-    int num_old_cookies,
-    int days_old) {
+CookieMonster* CreateMonsterFromStoreForGC(int num_cookies,
+                                           int num_old_cookies,
+                                           int days_old) {
   base::Time current(base::Time::Now());
   base::Time past_creation(base::Time::Now() - base::TimeDelta::FromDays(1000));
   scoped_refptr<MockSimplePersistentCookieStore> store(
@@ -209,19 +215,27 @@ CookieMonster* CreateMonsterFromStoreForGC(
         past_creation + base::TimeDelta::FromMicroseconds(i);
     base::Time expiration_time = current + base::TimeDelta::FromDays(30);
     base::Time last_access_time =
-        (i < num_old_cookies) ? current - base::TimeDelta::FromDays(days_old) :
-                                current;
-
-    CanonicalCookie cc(
-        GURL(), "a", "1", base::StringPrintf("h%05d.izzle", i), "/path",
-        creation_time, expiration_time, last_access_time, false, false,
-        COOKIE_PRIORITY_DEFAULT);
+        (i < num_old_cookies) ? current - base::TimeDelta::FromDays(days_old)
+                              : current;
+
+    CanonicalCookie cc(GURL(),
+                       "a",
+                       "1",
+                       base::StringPrintf("h%05d.izzle", i),
+                       "/path",
+                       creation_time,
+                       expiration_time,
+                       last_access_time,
+                       false,
+                       false,
+                       COOKIE_PRIORITY_DEFAULT);
     store->AddCookie(cc);
   }
 
   return new CookieMonster(store.get(), NULL);
 }
 
-MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() {}
+MockSimplePersistentCookieStore::~MockSimplePersistentCookieStore() {
+}
 
 }  // namespace net