clang-formatting files in //net/cookies to clear up a diff.

net/cookies/cookie_monster_store_test.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.
 
 // This file contains test infrastructure for multiple files
 // (current cookie_monster_unittest.cc and cookie_monster_perftest.cc)
 // that need to test out CookieMonster interactions with the backing store.
 // It should only be included by test code.
 
 #ifndef NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_
@@ skipping 16 matching lines @@
 // reference counted, we cannot post a callback to the message loop directly,
 // instead we post a LoadedCallbackTask.
 class LoadedCallbackTask
     : public base::RefCountedThreadSafe<LoadedCallbackTask> {
  public:
   typedef CookieMonster::PersistentCookieStore::LoadedCallback LoadedCallback;
 
   LoadedCallbackTask(LoadedCallback loaded_callback,
                      std::vector<CanonicalCookie*> cookies);
 
-  void Run() {
-    loaded_callback_.Run(cookies_);
-  }
+  void Run() { loaded_callback_.Run(cookies_); }
 
  private:
   friend class base::RefCountedThreadSafe<LoadedCallbackTask>;
   ~LoadedCallbackTask();
 
   LoadedCallback loaded_callback_;
   std::vector<CanonicalCookie*> cookies_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadedCallbackTask);
 };  // Wrapper class LoadedCallbackTask
 
 // Describes a call to one of the 3 functions of PersistentCookieStore.
 struct CookieStoreCommand {
   enum Type {
     ADD,
     UPDATE_ACCESS_TIME,
     REMOVE,
   };
 
   CookieStoreCommand(Type type, const CanonicalCookie& cookie)
-      : type(type),
-        cookie(cookie) {}
+      : type(type), cookie(cookie) {}
 
   Type type;
   CanonicalCookie cookie;
 };
 
 // Implementation of PersistentCookieStore that captures the
 // received commands and saves them to a list.
 // The result of calls to Load() can be configured using SetLoadExpectation().
-class MockPersistentCookieStore
-    : public CookieMonster::PersistentCookieStore {
+class MockPersistentCookieStore : public CookieMonster::PersistentCookieStore {
  public:
   typedef std::vector<CookieStoreCommand> CommandList;
 
   MockPersistentCookieStore();
 
-  void SetLoadExpectation(
-      bool return_value,
-      const std::vector<CanonicalCookie*>& result);
+  void SetLoadExpectation(bool return_value,
+                          const std::vector<CanonicalCookie*>& result);
 
-  const CommandList& commands() const {
-    return commands_;
-  }
+  const CommandList& commands() const { return commands_; }
 
   void Load(const LoadedCallback& loaded_callback) override;
 
   void LoadCookiesForKey(const std::string& key,
                          const LoadedCallback& loaded_callback) override;
 
   void AddCookie(const CanonicalCookie& cookie) override;
 
   void UpdateCookieAccessTime(const CanonicalCookie& cookie) override;
 
@@ skipping 15 matching lines @@
   // Indicates if the store has been fully loaded to avoid returning duplicate
   // cookies.
   bool loaded_;
 
   DISALLOW_COPY_AND_ASSIGN(MockPersistentCookieStore);
 };
 
 // Mock for CookieMonsterDelegate
 class MockCookieMonsterDelegate : public CookieMonsterDelegate {
  public:
-  typedef std::pair<CanonicalCookie, bool>
-      CookieNotification;
+  typedef std::pair<CanonicalCookie, bool> CookieNotification;
 
   MockCookieMonsterDelegate();
 
   const std::vector<CookieNotification>& changes() const { return changes_; }
 
   void reset() { changes_.clear(); }
 
   void OnCookieChanged(const CanonicalCookie& cookie,
                        bool removed,
                        CookieMonsterDelegate::ChangeCause cause) override;
 
   void OnLoaded() override;
 
  private:
   ~MockCookieMonsterDelegate() override;
 
   std::vector<CookieNotification> changes_;
 
   DISALLOW_COPY_AND_ASSIGN(MockCookieMonsterDelegate);
 };
 
 // Helper to build a single CanonicalCookie.
 CanonicalCookie BuildCanonicalCookie(const std::string& key,
                                      const std::string& cookie_line,
                                      const base::Time& creation_time);
 
 // Helper to build a list of CanonicalCookie*s.
-void AddCookieToList(
-    const std::string& key,
-    const std::string& cookie_line,
-    const base::Time& creation_time,
-    std::vector<CanonicalCookie*>* out_list);
+void AddCookieToList(const std::string& key,
+                     const std::string& cookie_line,
+                     const base::Time& creation_time,
+                     std::vector<CanonicalCookie*>* out_list);
 
 // Just act like a backing database.  Keep cookie information from
 // Add/Update/Delete and regurgitate it when Load is called.
 class MockSimplePersistentCookieStore
     : public CookieMonster::PersistentCookieStore {
  public:
   MockSimplePersistentCookieStore();
 
   void Load(const LoadedCallback& loaded_callback) override;
 
@@ skipping 24 matching lines @@
 };
 
 // Helper function for creating a CookieMonster backed by a
 // MockSimplePersistentCookieStore for garbage collection testing.
 //
 // Fill the store through import with |num_cookies| cookies, |num_old_cookies|
 // with access time Now()-days_old, the rest with access time Now().
 // Do two SetCookies().  Return whether each of the two SetCookies() took
 // longer than |gc_perf_micros| to complete, and how many cookie were
 // left in the store afterwards.
-CookieMonster* CreateMonsterFromStoreForGC(
-    int num_cookies,
-    int num_old_cookies,
-    int days_old);
+CookieMonster* CreateMonsterFromStoreForGC(int num_cookies,
+                                           int num_old_cookies,
+                                           int days_old);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_