CookieStore: Remove reference counting.

ios/net/cookies/cookie_store_ios.mm

 // 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 "ios/net/cookies/cookie_store_ios.h"
 
 #import <Foundation/Foundation.h>
 #include <stddef.h>
 
 #include "base/bind.h"
@@ skipping 274 matching lines @@
 
 CookieStoreIOS::CookieStoreIOS(
     net::CookieMonster::PersistentCookieStore* persistent_store)
     : CookieStoreIOS(persistent_store,
                      [NSHTTPCookieStorage sharedHTTPCookieStorage]) {
 }
 
 CookieStoreIOS::CookieStoreIOS(
     net::CookieMonster::PersistentCookieStore* persistent_store,
     NSHTTPCookieStorage* system_store)
-    : system_store_(system_store),
+    : cookie_monster_(new net::CookieMonster(persistent_store, nullptr)),
+      system_store_(system_store),
       creation_time_manager_(new CookieCreationTimeManager),
       metrics_enabled_(false),
       flush_delay_(base::TimeDelta::FromSeconds(10)),
       synchronization_state_(NOT_SYNCHRONIZED),
-      cookie_cache_(new CookieCache()) {
+      cookie_cache_(new CookieCache()),
+      weak_factory_(this) {
   DCHECK(system_store);
 
   NotificationTrampoline::GetInstance()->AddObserver(this);
-  cookie_monster_ = new net::CookieMonster(persistent_store, nullptr);
+
   cookie_monster_->SetPersistSessionCookies(true);
   cookie_monster_->SetForceKeepSessionState();
 }
 
+CookieStoreIOS::~CookieStoreIOS() {
+  NotificationTrampoline::GetInstance()->RemoveObserver(this);
+  STLDeleteContainerPairSecondPointers(hook_map_.begin(), hook_map_.end());
+}
+
 // static
 void CookieStoreIOS::SetCookiePolicy(CookiePolicy setting) {
   NSHTTPCookieAcceptPolicy policy = (setting == ALLOW)
                                         ? NSHTTPCookieAcceptPolicyAlways
                                         : NSHTTPCookieAcceptPolicyNever;
   NSHTTPCookieStorage* store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
   NSHTTPCookieAcceptPolicy current_policy = [store cookieAcceptPolicy];
   if (current_policy == policy)
     return;
   [store setCookieAcceptPolicy:policy];
   NotificationTrampoline::GetInstance()->NotifyCookiePolicyChanged();
 }
 
 // static
-CookieStoreIOS* CookieStoreIOS::CreateCookieStore(
+scoped_ptr<CookieStoreIOS> CookieStoreIOS::CreateCookieStore(
     NSHTTPCookieStorage* cookie_storage) {
   DCHECK(cookie_storage);
   // TODO(huey): Update this when CrNet supports multiple cookie jars.
   [cookie_storage setCookieAcceptPolicy:NSHTTPCookieAcceptPolicyAlways];
 
   // Create a cookie store with no persistent store backing. Then, populate
   // it from the system's cookie jar.
-  CookieStoreIOS* cookie_store = new CookieStoreIOS(nullptr, cookie_storage);
+  scoped_ptr<CookieStoreIOS> cookie_store(
+      new CookieStoreIOS(nullptr, cookie_storage));
   cookie_store->synchronization_state_ = SYNCHRONIZED;
   cookie_store->FlushStore(base::Closure());
   return cookie_store;
 }
 
 // static
 void CookieStoreIOS::SwitchSynchronizedStore(CookieStoreIOS* old_store,
                                              CookieStoreIOS* new_store) {
   DCHECK(new_store);
   DCHECK_NE(new_store, old_store);
@@ skipping 29 matching lines @@
     const SetCookiesCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->SetCookieWithOptionsAsync(url, cookie_line, options,
                                                  WrapSetCallback(callback));
       break;
     case SYNCHRONIZING:
       tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::SetCookieWithOptionsAsync, this, url,
-                     cookie_line, options, WrapSetCallback(callback)));
+          base::Bind(&CookieStoreIOS::SetCookieWithOptionsAsync,
+                     weak_factory_.GetWeakPtr(), url, cookie_line, options,
+                     WrapSetCallback(callback)));
       break;
     case SYNCHRONIZED:
       // The exclude_httponly() option would only be used by a javascript
       // engine.
       DCHECK(!options.exclude_httponly());
       // If cookies are not allowed, they are stashed in the CookieMonster, and
       // should be written there instead.
       DCHECK(SystemCookiesAllowed());
 
       base::Time server_time =
@@ skipping 54 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->SetCookieWithDetailsAsync(
           url, name, value, domain, path, creation_time, expiration_time,
           last_access_time, secure, http_only, same_site, enforce_strict_secure,
           priority, WrapSetCallback(callback));
       break;
     case SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(base::Bind(
-          &CookieStoreIOS::SetCookieWithDetailsAsync, this, url, name, value,
-          domain, path, creation_time, expiration_time, last_access_time,
-          secure, http_only, same_site, enforce_strict_secure, priority,
-          WrapSetCallback(callback)));
+      tasks_pending_synchronization_.push_back(
+          base::Bind(&CookieStoreIOS::SetCookieWithDetailsAsync,
+                     weak_factory_.GetWeakPtr(), url, name, value, domain, path,
+                     creation_time, expiration_time, last_access_time, secure,
+                     http_only, same_site, enforce_strict_secure, priority,
+                     WrapSetCallback(callback)));
       break;
     case SYNCHRONIZED:
       // If cookies are not allowed, they are stashed in the CookieMonster, and
       // should be written there instead.
       DCHECK(SystemCookiesAllowed());
 
       bool success = false;
 
       if (creation_time.is_null())
         creation_time = base::Time::Now();
@@ skipping 30 matching lines @@
     const net::CookieOptions& options,
     const GetCookiesCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->GetCookiesWithOptionsAsync(url, options, callback);
       break;
     case SYNCHRONIZING:
       tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::GetCookiesWithOptionsAsync, this, url,
-                     options, callback));
+          base::Bind(&CookieStoreIOS::GetCookiesWithOptionsAsync,
+                     weak_factory_.GetWeakPtr(), url, options, callback));
       break;
     case SYNCHRONIZED:
       // If cookies are not allowed, they are stashed in the CookieMonster, and
       // should be read from there instead.
       DCHECK(SystemCookiesAllowed());
       // The exclude_httponly() option would only be used by a javascript
       // engine.
       DCHECK(!options.exclude_httponly());
 
       // TODO(mkwst): If/when iOS supports Same-Site cookies, we'll need to pass
@@ skipping 11 matching lines @@
     const net::CookieOptions& options,
     const GetCookieListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->GetCookieListWithOptionsAsync(url, options, callback);
       break;
     case SYNCHRONIZING:
       tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::GetCookieListWithOptionsAsync, this, url,
-                     options, callback));
+          base::Bind(&CookieStoreIOS::GetCookieListWithOptionsAsync,
+                     weak_factory_.GetWeakPtr(), url, options, callback));
       break;
     case SYNCHRONIZED:
       if (!SystemCookiesAllowed()) {
         // If cookies are not allowed, the cookies are stashed in the
         // CookieMonster, so get them from there.
         cookie_monster_->GetCookieListWithOptionsAsync(url, options, callback);
         return;
       }
 
       // TODO(mkwst): If/when iOS supports Same-Site cookies, we'll need to pass
       // options in here as well. https://crbug.com/459154
       NSArray* cookies = GetCookiesForURL(system_store_,
                                           url, creation_time_manager_.get());
       net::CookieList cookie_list = CanonicalCookieListFromSystemCookies(
           cookies);
       if (!callback.is_null())
         callback.Run(cookie_list);
       break;
   }
 }
 
 void CookieStoreIOS::GetAllCookiesAsync(const GetCookieListCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->GetAllCookiesAsync(callback);
       break;
     case SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(base::Bind(
-          &CookieStoreIOS::GetAllCookiesAsync, this, callback));
+      tasks_pending_synchronization_.push_back(
+          base::Bind(&CookieStoreIOS::GetAllCookiesAsync,
+                     weak_factory_.GetWeakPtr(), callback));
       break;
     case SYNCHRONIZED:
       if (!SystemCookiesAllowed()) {
         // If cookies are not allowed, the cookies are stashed in the
         // CookieMonster, so get them from there.
         cookie_monster_->GetAllCookiesAsync(callback);
         return;
       }
 
       NSArray* cookies = GetAllCookies(system_store_,
@@ skipping 11 matching lines @@
                                        const std::string& cookie_name,
                                        const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->DeleteCookieAsync(url, cookie_name,
                                          WrapClosure(callback));
       break;
     case SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::DeleteCookieAsync, this, url, cookie_name,
-                     WrapClosure(callback)));
+      tasks_pending_synchronization_.push_back(base::Bind(
+          &CookieStoreIOS::DeleteCookieAsync, weak_factory_.GetWeakPtr(), url,
+          cookie_name, WrapClosure(callback)));
       break;
     case SYNCHRONIZED:
       NSArray* cookies = GetCookiesForURL(system_store_,
                                           url, creation_time_manager_.get());
       for (NSHTTPCookie* cookie in cookies) {
         if ([[cookie name]
                 isEqualToString:base::SysUTF8ToNSString(cookie_name)]) {
           [system_store_ deleteCookie:cookie];
           creation_time_manager_->DeleteCreationTime(cookie);
         }
       }
       if (!callback.is_null())
         callback.Run();
       break;
   }
 }
 
 void CookieStoreIOS::DeleteCanonicalCookieAsync(
     const CanonicalCookie& cookie,
     const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->DeleteCanonicalCookieAsync(cookie,
                                                   WrapDeleteCallback(callback));
       break;
     case SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::DeleteCanonicalCookieAsync, this, cookie,
-                     WrapDeleteCallback(callback)));
+      tasks_pending_synchronization_.push_back(base::Bind(
+          &CookieStoreIOS::DeleteCanonicalCookieAsync,
+          weak_factory_.GetWeakPtr(), cookie, WrapDeleteCallback(callback)));
       break;
     case SYNCHRONIZED:
       // This relies on the fact cookies are given unique creation dates.
       CookieFilterFunction filter = base::Bind(
           IsCookieCreatedBetween, cookie.CreationDate(), cookie.CreationDate());
       DeleteCookiesWithFilter(filter, callback);
   }
 }
 
 void CookieStoreIOS::DeleteAllCreatedBetweenAsync(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->DeleteAllCreatedBetweenAsync(
           delete_begin, delete_end, WrapDeleteCallback(callback));
       break;
     case SYNCHRONIZING:
       tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::DeleteAllCreatedBetweenAsync, this,
-                     delete_begin, delete_end, WrapDeleteCallback(callback)));
+          base::Bind(&CookieStoreIOS::DeleteAllCreatedBetweenAsync,
+                     weak_factory_.GetWeakPtr(), delete_begin, delete_end,
+                     WrapDeleteCallback(callback)));
       break;
     case SYNCHRONIZED:
       CookieFilterFunction filter =
           base::Bind(&IsCookieCreatedBetween, delete_begin, delete_end);
       DeleteCookiesWithFilter(filter, callback);
       break;
   }
 }
 
 void CookieStoreIOS::DeleteAllCreatedBetweenForHostAsync(
     const base::Time delete_begin,
     const base::Time delete_end,
     const GURL& url,
     const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->DeleteAllCreatedBetweenForHostAsync(
           delete_begin, delete_end, url, WrapDeleteCallback(callback));
       break;
     case SYNCHRONIZING:
-      tasks_pending_synchronization_.push_back(base::Bind(
-          &CookieStoreIOS::DeleteAllCreatedBetweenForHostAsync, this,
-          delete_begin, delete_end, url, WrapDeleteCallback(callback)));
+      tasks_pending_synchronization_.push_back(
+          base::Bind(&CookieStoreIOS::DeleteAllCreatedBetweenForHostAsync,
+                     weak_factory_.GetWeakPtr(), delete_begin, delete_end, url,
+                     WrapDeleteCallback(callback)));
       break;
     case SYNCHRONIZED:
       NSString* host = base::SysUTF8ToNSString(url.host());
       CookieFilterFunction filter = base::Bind(IsCookieCreatedBetweenForHost,
                                                delete_begin, delete_end, host);
       DeleteCookiesWithFilter(filter, callback);
       break;
   }
 }
 
 void CookieStoreIOS::DeleteSessionCookiesAsync(const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (metrics_enabled_)
     ResetCookieCountMetrics();
 
   switch (synchronization_state_) {
     case NOT_SYNCHRONIZED:
       cookie_monster_->DeleteSessionCookiesAsync(WrapDeleteCallback(callback));
       break;
     case SYNCHRONIZING:
       tasks_pending_synchronization_.push_back(
-          base::Bind(&CookieStoreIOS::DeleteSessionCookiesAsync, this,
-                     WrapDeleteCallback(callback)));
+          base::Bind(&CookieStoreIOS::DeleteSessionCookiesAsync,
+                     weak_factory_.GetWeakPtr(), WrapDeleteCallback(callback)));
       break;
     case SYNCHRONIZED:
       CookieFilterFunction filter = base::Bind(&IsCookieSessionCookie);
       DeleteCookiesWithFilter(filter, callback);
       break;
   }
 }
 
 void CookieStoreIOS::FlushStore(const base::Closure& closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (SystemCookiesAllowed()) {
     // If cookies are disabled, the system store is empty, and the cookies are
     // stashed on disk. Do not delete the cookies on the disk in this case.
     WriteToCookieMonster([system_store_ cookies]);
   }
   cookie_monster_->FlushStore(closure);
   flush_closure_.Cancel();
 }
 
 #pragma mark -
-#pragma mark Protected methods
-
-CookieStoreIOS::~CookieStoreIOS() {
-  NotificationTrampoline::GetInstance()->RemoveObserver(this);
-  STLDeleteContainerPairSecondPointers(hook_map_.begin(), hook_map_.end());
-}
-
-#pragma mark -
 #pragma mark Private methods
 
 void CookieStoreIOS::ClearSystemStore() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::scoped_nsobject<NSArray> copy(
       [[NSArray alloc] initWithArray:[system_store_ cookies]]);
   for (NSHTTPCookie* cookie in copy.get())
     [system_store_ deleteCookie:cookie];
   DCHECK_EQ(0u, [[system_store_ cookies] count]);
   creation_time_manager_->Clear();
 }
 
 void CookieStoreIOS::OnSystemCookiePolicyChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If the CookieStoreIOS is not synchronized or is not backed by
   // |NSHTTPCookieStorage sharedHTTPCookieStorage| this callback is irrelevant.
   if (synchronization_state_ == NOT_SYNCHRONIZED ||
       system_store_ != [NSHTTPCookieStorage sharedHTTPCookieStorage]) {
     return;
   }
 
   NSHTTPCookieAcceptPolicy policy =
       [system_store_ cookieAcceptPolicy];
   if (policy == NSHTTPCookieAcceptPolicyAlways) {
     // If cookies are disabled, the system cookie store should be empty.
     DCHECK(![[system_store_ cookies] count]);
     DCHECK(synchronization_state_ != SYNCHRONIZING);
     synchronization_state_ = SYNCHRONIZING;
-    cookie_monster_->GetAllCookiesAsync(
-        base::Bind(&CookieStoreIOS::AddCookiesToSystemStore, this));
+    cookie_monster_->GetAllCookiesAsync(base::Bind(
+        &CookieStoreIOS::AddCookiesToSystemStore, weak_factory_.GetWeakPtr()));
   } else {
     DCHECK_EQ(NSHTTPCookieAcceptPolicyNever, policy);
     // FlushStore() does not write the cookies to disk when they are disabled.
     // Explicitly copy them.
     WriteToCookieMonster([system_store_ cookies]);
     FlushStore(base::Closure());
     ClearSystemStore();
     if (synchronization_state_ == SYNCHRONIZING) {
       // If synchronization was in progress, abort it and leave the cookie store
       // empty.
@@ skipping 33 matching lines @@
   DCHECK(policy == NSHTTPCookieAcceptPolicyAlways ||
          ![[system_store_ cookies] count]);
 
   // If cookies are disabled, nothing is done now, the work will be done when
   // cookies are re-enabled.
   if (policy == NSHTTPCookieAcceptPolicyAlways) {
     if (synchronized) {
       synchronization_state_ = SYNCHRONIZING;
       ClearSystemStore();
       cookie_monster_->GetAllCookiesAsync(
-          base::Bind(&CookieStoreIOS::AddCookiesToSystemStore, this));
+          base::Bind(&CookieStoreIOS::AddCookiesToSystemStore,
+                     weak_factory_.GetWeakPtr()));
       return;
     } else {
       // Copy the cookies from the global store to |cookie_monster_|.
       FlushStore(base::Closure());
     }
   }
   synchronization_state_ = synchronized ? SYNCHRONIZED : NOT_SYNCHRONIZED;
 
   if (synchronization_state_ == NOT_SYNCHRONIZED) {
     // If there are pending tasks, then it means that the synchronization is
@@ skipping 117 matching lines @@
       RunCallbacksForCookies(key.first, key.second, removed_cookies, true);
       RunCallbacksForCookies(key.first, key.second, added_cookies, false);
     }
   }
 
   // Do not schedule a flush if one is already scheduled.
   if (!flush_closure_.IsCancelled())
     return;
 
   flush_closure_.Reset(base::Bind(&CookieStoreIOS::FlushStore,
-                                  base::Unretained(this), base::Closure()));
+                                  weak_factory_.GetWeakPtr(), base::Closure()));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, flush_closure_.callback(), flush_delay_);
 }
 
 scoped_ptr<net::CookieStore::CookieChangedSubscription>
 CookieStoreIOS::AddCallbackForCookie(const GURL& gurl,
                                      const std::string& name,
                                      const CookieChangedCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 74 matching lines @@
 
 void CookieStoreIOS::DidClearNSHTTPCookieStorageCookies(
     const DeleteCallback& delete_callback,
     int num_deleted) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CookieStoreIOSClient* client = net::GetCookieStoreIOSClient();
   DCHECK(client);
   auto sequenced_task_runner = client->GetTaskRunner();
   DCHECK(sequenced_task_runner);
-  auto callback = base::Bind(&CookieStoreIOS::DidClearBinaryCookiesFileCookies,
-                             this, delete_callback, num_deleted);
+  auto callback =
+      base::Bind(&CookieStoreIOS::DidClearBinaryCookiesFileCookies,
+                 weak_factory_.GetWeakPtr(), delete_callback, num_deleted);
   sequenced_task_runner.get()->PostTaskAndReply(
       FROM_HERE, base::Bind(&ClearAllCookiesFromBinaryCookiesFile), callback);
 }
 
 void CookieStoreIOS::DidClearBinaryCookiesFileCookies(
     const DeleteCallback& callback,
     int num_deleted_from_nshttp_cookie_storage) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CookieStoreIOSClient* client = net::GetCookieStoreIOSClient();
   DCHECK(client);
   client->DidChangeCookieStorage();
   if (!callback.is_null())
     callback.Run(num_deleted_from_nshttp_cookie_storage);
 }
 
 void CookieStoreIOS::UpdateCachesFromCookieMonster() {
   DCHECK(thread_checker_.CalledOnValidThread());
   for (const auto& hook_map_entry : hook_map_) {
     std::pair<GURL, std::string> key = hook_map_entry.first;
-    GetCookieListCallback callback =
-        base::Bind(&CookieStoreIOS::GotCookieListFor, this, key);
+    GetCookieListCallback callback = base::Bind(
+        &CookieStoreIOS::GotCookieListFor, weak_factory_.GetWeakPtr(), key);
     cookie_monster_->GetAllCookiesForURLAsync(key.first, callback);
   }
 }
 
 void CookieStoreIOS::UpdateCachesAfterSet(const SetCookiesCallback& callback,
                                           bool success) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (success)
     UpdateCachesFromCookieMonster();
   if (!callback.is_null())
@@ skipping 22 matching lines @@
   for (NSHTTPCookie* cookie in cookies) {
     base::Time created = creation_time_manager_->GetCreationTime(cookie);
     cookie_list.push_back(CanonicalCookieFromSystemCookie(cookie, created));
   }
   return cookie_list;
 }
 
 CookieStoreIOS::SetCookiesCallback CookieStoreIOS::WrapSetCallback(
     const SetCookiesCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterSet, this, callback);
+  return base::Bind(&CookieStoreIOS::UpdateCachesAfterSet,
+                    weak_factory_.GetWeakPtr(), callback);
 }
 
 CookieStoreIOS::DeleteCallback CookieStoreIOS::WrapDeleteCallback(
     const DeleteCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterDelete, this, callback);
+  return base::Bind(&CookieStoreIOS::UpdateCachesAfterDelete,
+                    weak_factory_.GetWeakPtr(), callback);
 }
 
 base::Closure CookieStoreIOS::WrapClosure(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure, this, callback);
+  return base::Bind(&CookieStoreIOS::UpdateCachesAfterClosure,
+                    weak_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace net