Revert revision 176015

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 <vector>
 
@@ skipping 171 matching lines @@
     *store_id = cookies_helpers::GetStoreIdFromProfile(store_profile);
   }
 
   if (context)
     *context = store_profile->GetRequestContext();
   DCHECK(context);
 
   return true;
 }
 
-CookiesGetFunction::CookiesGetFunction() {
+GetCookieFunction::GetCookieFunction() {
 }
 
-CookiesGetFunction::~CookiesGetFunction() {
+GetCookieFunction::~GetCookieFunction() {
 }
 
-bool CookiesGetFunction::RunImpl() {
+bool GetCookieFunction::RunImpl() {
   parsed_args_ = Get::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
   // Read/validate input parameters.
   if (!ParseUrl(parsed_args_->details.url, &url_, true))
     return false;
 
   std::string store_id = parsed_args_->details.store_id.get() ?
       *parsed_args_->details.store_id : "";
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
   store_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   store_context_ = store_context;
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CookiesGetFunction::GetCookieOnIOThread, this));
+      base::Bind(&GetCookieFunction::GetCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
-void CookiesGetFunction::GetCookieOnIOThread() {
+void GetCookieFunction::GetCookieOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::CookieStore* cookie_store =
       store_context_->GetURLRequestContext()->cookie_store();
   cookies_helpers::GetCookieListFromStore(
       cookie_store, url_,
-      base::Bind(&CookiesGetFunction::GetCookieCallback, this));
+      base::Bind(&GetCookieFunction::GetCookieCallback, this));
 }
 
-void CookiesGetFunction::GetCookieCallback(const net::CookieList& cookie_list) {
+void GetCookieFunction::GetCookieCallback(const net::CookieList& cookie_list) {
   net::CookieList::const_iterator it;
   for (it = cookie_list.begin(); it != cookie_list.end(); ++it) {
     // 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<Cookie> cookie(
           cookies_helpers::CreateCookie(*it, *parsed_args_->details.store_id));
       results_ = Get::Results::Create(*cookie);
       break;
     }
   }
 
   // The cookie doesn't exist; return null.
   if (it == cookie_list.end())
     SetResult(Value::CreateNullValue());
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&CookiesGetFunction::RespondOnUIThread, this));
+      base::Bind(&GetCookieFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
-void CookiesGetFunction::RespondOnUIThread() {
+void GetCookieFunction::RespondOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SendResponse(true);
 }
 
-CookiesGetAllFunction::CookiesGetAllFunction() {
+GetAllCookiesFunction::GetAllCookiesFunction() {
 }
 
-CookiesGetAllFunction::~CookiesGetAllFunction() {
+GetAllCookiesFunction::~GetAllCookiesFunction() {
 }
 
-bool CookiesGetAllFunction::RunImpl() {
+bool GetAllCookiesFunction::RunImpl() {
   parsed_args_ = GetAll::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
   if (parsed_args_->details.url.get() &&
       !ParseUrl(*parsed_args_->details.url, &url_, false)) {
     return false;
   }
 
   std::string store_id = parsed_args_->details.store_id.get() ?
       *parsed_args_->details.store_id : "";
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
   store_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CookiesGetAllFunction::GetAllCookiesOnIOThread, this));
+      base::Bind(&GetAllCookiesFunction::GetAllCookiesOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
-void CookiesGetAllFunction::GetAllCookiesOnIOThread() {
+void GetAllCookiesFunction::GetAllCookiesOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::CookieStore* cookie_store =
       store_context_->GetURLRequestContext()->cookie_store();
   cookies_helpers::GetCookieListFromStore(
       cookie_store, url_,
-      base::Bind(&CookiesGetAllFunction::GetAllCookiesCallback, this));
+      base::Bind(&GetAllCookiesFunction::GetAllCookiesCallback, this));
 }
 
-void CookiesGetAllFunction::GetAllCookiesCallback(
+void GetAllCookiesFunction::GetAllCookiesCallback(
     const net::CookieList& cookie_list) {
   const extensions::Extension* extension = GetExtension();
   if (extension) {
     std::vector<linked_ptr<Cookie> > match_vector;
     cookies_helpers::AppendMatchingCookiesToVector(
         cookie_list, url_, &parsed_args_->details,
         GetExtension(), &match_vector);
 
     results_ = GetAll::Results::Create(match_vector);
   }
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&CookiesGetAllFunction::RespondOnUIThread, this));
+      base::Bind(&GetAllCookiesFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
-void CookiesGetAllFunction::RespondOnUIThread() {
+void GetAllCookiesFunction::RespondOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SendResponse(true);
 }
 
-CookiesSetFunction::CookiesSetFunction() : success_(false) {
+SetCookieFunction::SetCookieFunction() : success_(false) {
 }
 
-CookiesSetFunction::~CookiesSetFunction() {
+SetCookieFunction::~SetCookieFunction() {
 }
 
-bool CookiesSetFunction::RunImpl() {
+bool SetCookieFunction::RunImpl() {
   parsed_args_ = Set::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
   // Read/validate input parameters.
   if (!ParseUrl(parsed_args_->details.url, &url_, true))
       return false;
 
   std::string store_id = parsed_args_->details.store_id.get() ?
       *parsed_args_->details.store_id : "";
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
   store_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CookiesSetFunction::SetCookieOnIOThread, this));
+      base::Bind(&SetCookieFunction::SetCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
-void CookiesSetFunction::SetCookieOnIOThread() {
+void SetCookieFunction::SetCookieOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::CookieMonster* cookie_monster =
       store_context_->GetURLRequestContext()->cookie_store()->
       GetCookieMonster();
 
   base::Time expiration_time;
   if (parsed_args_->details.expiration_date.get()) {
     // Time::FromDoubleT converts double time 0 to empty Time object. So we need
     // to do special handling here.
     expiration_time = (*parsed_args_->details.expiration_date == 0) ?
         base::Time::UnixEpoch() :
         base::Time::FromDoubleT(*parsed_args_->details.expiration_date);
   }
 
   cookie_monster->SetCookieWithDetailsAsync(
       url_,
       parsed_args_->details.name.get() ? *parsed_args_->details.name : "",
       parsed_args_->details.value.get() ? *parsed_args_->details.value : "",
       parsed_args_->details.domain.get() ? *parsed_args_->details.domain : "",
       parsed_args_->details.path.get() ? *parsed_args_->details.path : "",
       expiration_time,
       parsed_args_->details.secure.get() ?
           *parsed_args_->details.secure.get() :
           false,
       parsed_args_->details.http_only.get() ?
           *parsed_args_->details.http_only :
           false,
-      base::Bind(&CookiesSetFunction::PullCookie, this));
+      base::Bind(&SetCookieFunction::PullCookie, this));
 }
 
-void CookiesSetFunction::PullCookie(bool set_cookie_result) {
+void SetCookieFunction::PullCookie(bool set_cookie_result) {
   // Pull the newly set cookie.
   net::CookieMonster* cookie_monster =
       store_context_->GetURLRequestContext()->cookie_store()->
       GetCookieMonster();
   success_ = set_cookie_result;
   cookies_helpers::GetCookieListFromStore(
       cookie_monster, url_,
-      base::Bind(&CookiesSetFunction::PullCookieCallback, this));
+      base::Bind(&SetCookieFunction::PullCookieCallback, this));
 }
 
-void CookiesSetFunction::PullCookieCallback(
-    const net::CookieList& cookie_list) {
+void SetCookieFunction::PullCookieCallback(const net::CookieList& cookie_list) {
   net::CookieList::const_iterator it;
   for (it = cookie_list.begin(); it != cookie_list.end(); ++it) {
     // 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 : "";
     if (it->Name() == name) {
       scoped_ptr<Cookie> cookie(
           cookies_helpers::CreateCookie(*it, *parsed_args_->details.store_id));
       results_ = Set::Results::Create(*cookie);
       break;
     }
   }
 
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&CookiesSetFunction::RespondOnUIThread, this));
+      base::Bind(&SetCookieFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
-void CookiesSetFunction::RespondOnUIThread() {
+void SetCookieFunction::RespondOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!success_) {
     std::string name = parsed_args_->details.name.get() ?
         *parsed_args_->details.name : "";
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kCookieSetFailedError, name);
   }
   SendResponse(success_);
 }
 
-CookiesRemoveFunction::CookiesRemoveFunction() {
+RemoveCookieFunction::RemoveCookieFunction() {
 }
 
-CookiesRemoveFunction::~CookiesRemoveFunction() {
+RemoveCookieFunction::~RemoveCookieFunction() {
 }
 
-bool CookiesRemoveFunction::RunImpl() {
+bool RemoveCookieFunction::RunImpl() {
   parsed_args_ = Remove::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parsed_args_.get());
 
   // Read/validate input parameters.
   if (!ParseUrl(parsed_args_->details.url, &url_, true))
     return false;
 
   std::string store_id = parsed_args_->details.store_id.get() ?
       *parsed_args_->details.store_id : "";
   net::URLRequestContextGetter* store_context = NULL;
   if (!ParseStoreContext(&store_id, &store_context))
     return false;
   store_context_ = store_context;
   if (!parsed_args_->details.store_id.get())
     parsed_args_->details.store_id.reset(new std::string(store_id));
 
   // Pass the work off to the IO thread.
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CookiesRemoveFunction::RemoveCookieOnIOThread, this));
+      base::Bind(&RemoveCookieFunction::RemoveCookieOnIOThread, this));
   DCHECK(rv);
 
   // Will return asynchronously.
   return true;
 }
 
-void CookiesRemoveFunction::RemoveCookieOnIOThread() {
+void RemoveCookieFunction::RemoveCookieOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Remove the cookie
   net::CookieStore* cookie_store =
       store_context_->GetURLRequestContext()->cookie_store();
   cookie_store->DeleteCookieAsync(
       url_, parsed_args_->details.name,
-      base::Bind(&CookiesRemoveFunction::RemoveCookieCallback, this));
+      base::Bind(&RemoveCookieFunction::RemoveCookieCallback, this));
 }
 
-void CookiesRemoveFunction::RemoveCookieCallback() {
+void RemoveCookieFunction::RemoveCookieCallback() {
   // Build the callback result
   Remove::Results::Details details;
   details.name = parsed_args_->details.name;
   details.url = url_.spec();
   details.store_id = *parsed_args_->details.store_id;
   results_ = Remove::Results::Create(details);
 
   // Return to UI thread
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&CookiesRemoveFunction::RespondOnUIThread, this));
+      base::Bind(&RemoveCookieFunction::RespondOnUIThread, this));
   DCHECK(rv);
 }
 
-void CookiesRemoveFunction::RespondOnUIThread() {
+void RemoveCookieFunction::RespondOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SendResponse(true);
 }
 
-bool CookiesGetAllCookieStoresFunction::RunImpl() {
+bool GetAllCookieStoresFunction::RunImpl() {
   Profile* original_profile = profile();
   DCHECK(original_profile);
   scoped_ptr<ListValue> original_tab_ids(new ListValue());
   Profile* incognito_profile = NULL;
   scoped_ptr<ListValue> incognito_tab_ids;
   if (include_incognito() && profile()->HasOffTheRecordProfile()) {
     incognito_profile = profile()->GetOffTheRecordProfile();
     if (incognito_profile)
       incognito_tab_ids.reset(new ListValue());
   }
@@ skipping 22 matching lines @@
   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()));
   }
   results_ = GetAllCookieStores::Results::Create(cookie_stores);
   return true;
 }
 
-void CookiesGetAllCookieStoresFunction::Run() {
+void GetAllCookieStoresFunction::Run() {
   SendResponse(RunImpl());
 }
 
 CookiesAPI::CookiesAPI(Profile* profile)
     : profile_(profile) {
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, keys::kOnChanged);
 }
 
 CookiesAPI::~CookiesAPI() {
@@ skipping 11 matching lines @@
   return &g_factory.Get();
 }
 
 void CookiesAPI::OnListenerAdded(
     const extensions::EventListenerInfo& details) {
   cookies_event_router_.reset(new CookiesEventRouter(profile_));
   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
 }
 
 }  // namespace extensions