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

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Defines the Chrome Extensions Cookies API functions for accessing internet
   6 // cookies, as specified in the extension API JSON.
   7
   8 #ifndef CHROME_BROWSER_EXTENSIONS_API_COOKIES_COOKIES_API_H_
   9 #define CHROME_BROWSER_EXTENSIONS_API_COOKIES_COOKIES_API_H_
  10
  11 #include <string>
  12
  13 #include "base/compiler_specific.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "chrome/browser/extensions/chrome_extension_function.h"
  17 #include "chrome/browser/net/chrome_cookie_notification_details.h"
  18 #include "chrome/common/extensions/api/cookies.h"
  19 #include "content/public/browser/notification_observer.h"
  20 #include "content/public/browser/notification_registrar.h"
  21 #include "extensions/browser/browser_context_keyed_api_factory.h"
  22 #include "extensions/browser/event_router.h"
  23 #include "net/cookies/canonical_cookie.h"
  24 #include "url/gurl.h"
  25
  26 namespace net {
  27 class URLRequestContextGetter;
  28 }
  29
  30 namespace extensions {
  31
  32 // Observes CookieMonster notifications and routes them as events to the
  33 // extension system.
  34 class CookiesEventRouter : public content::NotificationObserver {
  35  public:
  36   explicit CookiesEventRouter(content::BrowserContext* context);
  37   ~CookiesEventRouter() override;
  38
  39  private:
  40   // content::NotificationObserver implementation.
  41   void Observe(int type,
  42                const content::NotificationSource& source,
  43                const content::NotificationDetails& details) override;
  44
  45   // Handler for the COOKIE_CHANGED event. The method takes the details of such
  46   // an event and constructs a suitable JSON formatted extension event from it.
  47   void CookieChanged(Profile* profile, ChromeCookieDetails* details);
  48
  49   // This method dispatches events to the extension message service.
  50   void DispatchEvent(content::BrowserContext* context,
  51                      events::HistogramValue histogram_value,
  52                      const std::string& event_name,
  53                      scoped_ptr<base::ListValue> event_args,
  54                      GURL& cookie_domain);
  55
  56   // Used for tracking registrations to CookieMonster notifications.
  57   content::NotificationRegistrar registrar_;
  58
  59   Profile* profile_;
  60
  61   DISALLOW_COPY_AND_ASSIGN(CookiesEventRouter);
  62 };
  63
  64 // Implements the cookies.get() extension function.
  65 class CookiesGetFunction : public ChromeAsyncExtensionFunction {
  66  public:
  67   DECLARE_EXTENSION_FUNCTION("cookies.get", COOKIES_GET)
  68
  69   CookiesGetFunction();
  70
  71  protected:
  72   ~CookiesGetFunction() override;
  73
  74   // ExtensionFunction:
  75   bool RunAsync() override;
  76
  77  private:
  78   void GetCookieOnIOThread();
  79   void RespondOnUIThread();
  80   void GetCookieCallback(const net::CookieList& cookie_list);
  81
  82   GURL url_;
  83   scoped_refptr<net::URLRequestContextGetter> store_browser_context_;
  84   scoped_ptr<api::cookies::Get::Params> parsed_args_;
  85 };
  86
  87 // Implements the cookies.getAll() extension function.
  88 class CookiesGetAllFunction : public ChromeAsyncExtensionFunction {
  89  public:
  90   DECLARE_EXTENSION_FUNCTION("cookies.getAll", COOKIES_GETALL)
  91
  92   CookiesGetAllFunction();
  93
  94  protected:
  95   ~CookiesGetAllFunction() override;
  96
  97   // ExtensionFunction:
  98   bool RunAsync() override;
  99
 100  private:
 101   void GetAllCookiesOnIOThread();
 102   void RespondOnUIThread();
 103   void GetAllCookiesCallback(const net::CookieList& cookie_list);
 104
 105   GURL url_;
 106   scoped_refptr<net::URLRequestContextGetter> store_browser_context_;
 107   scoped_ptr<api::cookies::GetAll::Params> parsed_args_;
 108 };
 109
 110 // Implements the cookies.set() extension function.
 111 class CookiesSetFunction : public ChromeAsyncExtensionFunction {
 112  public:
 113   DECLARE_EXTENSION_FUNCTION("cookies.set", COOKIES_SET)
 114
 115   CookiesSetFunction();
 116
 117  protected:
 118   ~CookiesSetFunction() override;
 119   bool RunAsync() override;
 120
 121  private:
 122   void SetCookieOnIOThread();
 123   void RespondOnUIThread();
 124   void PullCookie(bool set_cookie_);
 125   void PullCookieCallback(const net::CookieList& cookie_list);
 126
 127   GURL url_;
 128   bool success_;
 129   scoped_refptr<net::URLRequestContextGetter> store_browser_context_;
 130   scoped_ptr<api::cookies::Set::Params> parsed_args_;
 131 };
 132
 133 // Implements the cookies.remove() extension function.
 134 class CookiesRemoveFunction : public ChromeAsyncExtensionFunction {
 135  public:
 136   DECLARE_EXTENSION_FUNCTION("cookies.remove", COOKIES_REMOVE)
 137
 138   CookiesRemoveFunction();
 139
 140  protected:
 141   ~CookiesRemoveFunction() override;
 142
 143   // ExtensionFunction:
 144   bool RunAsync() override;
 145
 146  private:
 147   void RemoveCookieOnIOThread();
 148   void RespondOnUIThread();
 149   void RemoveCookieCallback();
 150
 151   GURL url_;
 152   scoped_refptr<net::URLRequestContextGetter> store_browser_context_;
 153   scoped_ptr<api::cookies::Remove::Params> parsed_args_;
 154 };
 155
 156 // Implements the cookies.getAllCookieStores() extension function.
 157 class CookiesGetAllCookieStoresFunction : public ChromeSyncExtensionFunction {
 158  public:
 159   DECLARE_EXTENSION_FUNCTION("cookies.getAllCookieStores",
 160                              COOKIES_GETALLCOOKIESTORES)
 161
 162  protected:
 163   ~CookiesGetAllCookieStoresFunction() override {}
 164
 165   // ExtensionFunction:
 166   bool RunSync() override;
 167 };
 168
 169 class CookiesAPI : public BrowserContextKeyedAPI, public EventRouter::Observer {
 170  public:
 171   explicit CookiesAPI(content::BrowserContext* context);
 172   ~CookiesAPI() override;
 173
 174   // KeyedService implementation.
 175   void Shutdown() override;
 176
 177   // BrowserContextKeyedAPI implementation.
 178   static BrowserContextKeyedAPIFactory<CookiesAPI>* GetFactoryInstance();
 179
 180   // EventRouter::Observer implementation.
 181   void OnListenerAdded(const EventListenerInfo& details) override;
 182
 183  private:
 184   friend class BrowserContextKeyedAPIFactory<CookiesAPI>;
 185
 186   content::BrowserContext* browser_context_;
 187
 188   // BrowserContextKeyedAPI implementation.
 189   static const char* service_name() {
 190     return "CookiesAPI";
 191   }
 192   static const bool kServiceIsNULLWhileTesting = true;
 193
 194   // Created lazily upon OnListenerAdded.
 195   scoped_ptr<CookiesEventRouter> cookies_event_router_;
 196
 197   DISALLOW_COPY_AND_ASSIGN(CookiesAPI);
 198 };
 199
 200 }  // namespace extensions
 201
 202 #endif  // CHROME_BROWSER_EXTENSIONS_API_COOKIES_COOKIES_API_H_