Adding callbacks to `chrome.cookies.{set,remove}`.

chrome/browser/extensions/extension_cookies_api.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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/extension_cookies_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/task.h"
 #include "base/values.h"
@@ skipping 255 matching lines @@
 SetCookieFunction::SetCookieFunction()
     : secure_(false),
       http_only_(false),
       success_(false) {
 }
 
 SetCookieFunction::~SetCookieFunction() {
 }
 
 bool SetCookieFunction::RunImpl() {
+  // Start with "null" being returned to callback, in case things fail in

[Aaron Boodman, 2011/02/15 22:26:04]

There is no need to explicitly set the result to null. The system will send no
arguments to the callback in the case of error, and will set the lastError
property so that the error is detectable.

+  // this synchronous bit of the workflow.
+  result_.reset(Value::CreateNullValue());
+
   // Return false if the arguments are malformed.
   DictionaryValue* details;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
   DCHECK(details);
 
   // Read/validate input parameters.
   if (!ParseUrl(details, &url_, true))
       return false;
   // The macros below return false if argument types are not as expected.
   if (details->HasKey(keys::kNameKey))
@@ skipping 43 matching lines @@
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(this, &SetCookieFunction::SetCookieOnIOThread));
   DCHECK(rv);
 
   // Will finish asynchronously.
   return true;
 }
 
 void SetCookieFunction::SetCookieOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::CookieMonster* cookie_monster =
-      store_context_->GetCookieStore()->GetCookieMonster();
+  net::CookieStore* cookie_store = store_context_->GetCookieStore();
+  net::CookieMonster* cookie_monster = cookie_store->GetCookieMonster();
   success_ = cookie_monster->SetCookieWithDetails(
       url_, name_, value_, domain_, path_, expiration_time_,
       secure_, http_only_);
 
+  // Pull the newly set cookie.
+  cookie_list_ =
+      extension_cookies_helpers::GetCookieListFromStore(cookie_store, url_);
+
   bool rv = BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(this, &SetCookieFunction::RespondOnUIThread));
   DCHECK(rv);
 }
 
 void SetCookieFunction::RespondOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!success_) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kCookieSetFailedError, name_);
+  } else {
+    net::CookieList::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() == name_) {
+        result_.reset(
+            extension_cookies_helpers::CreateCookieValue(*it, store_id_));
+        break;
+      }
+    }
   }
+
   SendResponse(success_);
 }
 
 namespace {
 
 class RemoveCookieTask : public Task {
  public:
   RemoveCookieTask(const GURL& url,
                    const std::string& name,
                    const scoped_refptr<URLRequestContextGetter>& context_getter)
@@ skipping 10 matching lines @@
   const GURL url_;
   const std::string name_;
   const scoped_refptr<URLRequestContextGetter> context_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveCookieTask);
 };
 
 }  // namespace
 
 bool RemoveCookieFunction::RunImpl() {
+  // Start with "null" being returned to callback, in case things fail in
+  // this syncronous bit of the workflow.
+  result_.reset(Value::CreateNullValue());
+
   // Return false if the arguments are malformed.
   DictionaryValue* details;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &details));
   DCHECK(details);
 
   // Read/validate input parameters.
   GURL url;
   if (!ParseUrl(details, &url, true))
     return false;
 
   std::string name;
   // Get the cookie name string or return false.
   EXTENSION_FUNCTION_VALIDATE(details->GetString(keys::kNameKey, &name));
 
   URLRequestContextGetter* store_context = NULL;
-  if (!ParseStoreContext(details, &store_context, NULL))
+  std::string store_id_string;
+  if (!ParseStoreContext(details, &store_context, &store_id_string))
     return false;
   DCHECK(store_context);
 
   // We don't bother to synchronously wait for the result here, because
   // CookieMonster is only ever accessed on the IO thread, so any other accesses
   // should happen after this.
   bool rv = BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       new RemoveCookieTask(url, name, make_scoped_refptr(store_context)));
   DCHECK(rv);
 
+  DictionaryValue* resultDictionary = new DictionaryValue();
+  std::string url_string;
+  details->GetString(keys::kUrlKey, &url_string);
+  resultDictionary->SetString(keys::kNameKey, name);
+  resultDictionary->SetString(keys::kUrlKey, url_string);
+  resultDictionary->SetString(keys::kStoreIdKey, store_id_string);
+  result_.reset(resultDictionary);
+
   return true;
 }
 
 void RemoveCookieFunction::Run() {
   SendResponse(RunImpl());
 }
 
 bool GetAllCookieStoresFunction::RunImpl() {
   Profile* original_profile = profile();
   DCHECK(original_profile);
@@ skipping 34 matching lines @@
         extension_cookies_helpers::CreateCookieStoreValue(
             incognito_profile, incognito_tab_ids.release()));
   }
   result_.reset(cookie_store_list);
   return true;
 }
 
 void GetAllCookieStoresFunction::Run() {
   SendResponse(RunImpl());
 }