[Extensions] Convert APIs to use movable types [3]

chrome/browser/extensions/api/cookies/cookies_api.cc

 // 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.
 
 // Implements the Chrome Extensions Cookies API.
 
 #include "chrome/browser/extensions/api/cookies/cookies_api.h"
 
 #include <utility>
 #include <vector>
@@ skipping 125 matching lines @@
   }
 }
 
 void CookiesEventRouter::CookieChanged(
     Profile* profile,
     ChromeCookieDetails* details) {
   scoped_ptr<base::ListValue> args(new base::ListValue());
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetBoolean(keys::kRemovedKey, details->removed);
 
-  scoped_ptr<cookies::Cookie> cookie(cookies_helpers::CreateCookie(
-      *details->cookie, cookies_helpers::GetStoreIdFromProfile(profile)));
-  dict->Set(keys::kCookieKey, cookie->ToValue().release());
+  cookies::Cookie cookie = cookies_helpers::CreateCookie(
+      *details->cookie, cookies_helpers::GetStoreIdFromProfile(profile));
+  dict->Set(keys::kCookieKey, cookie.ToValue());
 
   // Map the internal cause to an external string.
   std::string cause;
   switch (details->cause) {
     case net::CookieMonsterDelegate::CHANGE_COOKIE_EXPLICIT:
       cause = keys::kExplicitChangeCause;
       break;
 
     case net::CookieMonsterDelegate::CHANGE_COOKIE_OVERWRITE:
       cause = keys::kOverwriteChangeCause;
@@ skipping 77 matching lines @@
 void CookiesGetFunction::GetCookieOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::CookieStore* cookie_store =
       store_browser_context_->GetURLRequestContext()->cookie_store();
   cookies_helpers::GetCookieListFromStore(
       cookie_store, url_,
       base::Bind(&CookiesGetFunction::GetCookieCallback, this));
 }
 
 void CookiesGetFunction::GetCookieCallback(const net::CookieList& cookie_list) {
-  net::CookieList::const_iterator it;
-  for (it = cookie_list.begin(); it != cookie_list.end(); ++it) {
+  for (const net::CanonicalCookie& cookie : cookie_list) {
     // Return the first matching cookie. Relies on the fact that the
     // CookieMonster returns them in canonical order (longest path, then
     // earliest creation time).
-    if (it->Name() == parsed_args_->details.name) {
-      scoped_ptr<cookies::Cookie> cookie(
-          cookies_helpers::CreateCookie(*it, *parsed_args_->details.store_id));
-      results_ = Get::Results::Create(*cookie);
+    if (cookie.Name() == parsed_args_->details.name) {
+      cookies::Cookie api_cookie = cookies_helpers::CreateCookie(
+          cookie, *parsed_args_->details.store_id);
+      results_ = Get::Results::Create(api_cookie);
       break;
     }
   }
 
   // The cookie doesn't exist; return null.
-  if (it == cookie_list.end())
+  if (!results_)
     SetResult(base::Value::CreateNullValue());
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CookiesGetFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
 void CookiesGetFunction::RespondOnUIThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 39 matching lines @@
   net::CookieStore* cookie_store =
       store_browser_context_->GetURLRequestContext()->cookie_store();
   cookies_helpers::GetCookieListFromStore(
       cookie_store, url_,
       base::Bind(&CookiesGetAllFunction::GetAllCookiesCallback, this));
 }
 
 void CookiesGetAllFunction::GetAllCookiesCallback(
     const net::CookieList& cookie_list) {
   if (extension()) {
-    std::vector<linked_ptr<cookies::Cookie>> match_vector;
+    std::vector<cookies::Cookie> match_vector;
     cookies_helpers::AppendMatchingCookiesToVector(
         cookie_list, url_, &parsed_args_->details, extension(), &match_vector);
 
     results_ = GetAll::Results::Create(match_vector);
   }
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CookiesGetAllFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
@@ skipping 98 matching lines @@
   net::CookieStore* cookie_store =
       store_browser_context_->GetURLRequestContext()->cookie_store();
   success_ = set_cookie_result;
   cookies_helpers::GetCookieListFromStore(
       cookie_store, url_,
       base::Bind(&CookiesSetFunction::PullCookieCallback, this));
 }
 
 void CookiesSetFunction::PullCookieCallback(
     const net::CookieList& cookie_list) {
-  net::CookieList::const_iterator it;
-  for (it = cookie_list.begin(); it != cookie_list.end(); ++it) {
+  for (const net::CanonicalCookie& cookie : cookie_list) {
     // Return the first matching cookie. Relies on the fact that the
     // CookieMonster returns them in canonical order (longest path, then
     // earliest creation time).
     std::string name =
         parsed_args_->details.name.get() ? *parsed_args_->details.name
                                          : std::string();
-    if (it->Name() == name) {
-      scoped_ptr<cookies::Cookie> cookie(
-          cookies_helpers::CreateCookie(*it, *parsed_args_->details.store_id));
-      results_ = Set::Results::Create(*cookie);
+    if (cookie.Name() == name) {
+      cookies::Cookie api_cookie = cookies_helpers::CreateCookie(
+          cookie, *parsed_args_->details.store_id);
+      results_ = Set::Results::Create(api_cookie);
       break;
     }
   }
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CookiesSetFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
@@ skipping 91 matching lines @@
   // whether the browser is regular or incognito.
   for (auto* browser : *BrowserList::GetInstance()) {
     if (browser->profile() == original_profile) {
       cookies_helpers::AppendToTabIdList(browser, original_tab_ids.get());
     } else if (incognito_tab_ids.get() &&
                browser->profile() == incognito_profile) {
       cookies_helpers::AppendToTabIdList(browser, incognito_tab_ids.get());
     }
   }
   // Return a list of all cookie stores with at least one open tab.
-  std::vector<linked_ptr<cookies::CookieStore>> cookie_stores;
+  std::vector<cookies::CookieStore> cookie_stores;
   if (original_tab_ids->GetSize() > 0) {
-    cookie_stores.push_back(make_linked_ptr(
-        cookies_helpers::CreateCookieStore(
-            original_profile, original_tab_ids.release()).release()));
+    cookie_stores.push_back(cookies_helpers::CreateCookieStore(
+        original_profile, original_tab_ids.release()));
   }
   if (incognito_tab_ids.get() && incognito_tab_ids->GetSize() > 0 &&
       incognito_profile) {
-    cookie_stores.push_back(make_linked_ptr(
-        cookies_helpers::CreateCookieStore(
-            incognito_profile, incognito_tab_ids.release()).release()));
+    cookie_stores.push_back(cookies_helpers::CreateCookieStore(
+        incognito_profile, incognito_tab_ids.release()));
   }
   results_ = GetAllCookieStores::Results::Create(cookie_stores);
   return true;
 }
 
 CookiesAPI::CookiesAPI(content::BrowserContext* context)
     : browser_context_(context) {
   EventRouter::Get(browser_context_)
       ->RegisterObserver(this, cookies::OnChanged::kEventName);
 }
@@ skipping 12 matching lines @@
 BrowserContextKeyedAPIFactory<CookiesAPI>* CookiesAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 void CookiesAPI::OnListenerAdded(const EventListenerInfo& details) {
   cookies_event_router_.reset(new CookiesEventRouter(browser_context_));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions