src/chrome/browser/extensions/api/cookies/cookies_helpers.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 common functionality used by the implementation of the Chrome
   6 // Extensions Cookies API implemented in
   7 // chrome/browser/extensions/api/cookies/cookies_api.cc. This separate interface
   8 // exposes pieces of the API implementation mainly for unit testing purposes.
   9
  10 #ifndef CHROME_BROWSER_EXTENSIONS_API_COOKIES_COOKIES_HELPERS_H_
  11 #define CHROME_BROWSER_EXTENSIONS_API_COOKIES_COOKIES_HELPERS_H_
  12
  13 #include <string>
  14 #include <vector>
  15
  16 #include "base/memory/linked_ptr.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "chrome/common/extensions/api/cookies.h"
  19 #include "net/cookies/cookie_monster.h"
  20 #include "net/cookies/canonical_cookie.h"
  21
  22 class Browser;
  23 class Profile;
  24
  25 namespace base {
  26 class DictionaryValue;
  27 class ListValue;
  28 }
  29
  30 namespace net {
  31 class CanonicalCookie;
  32 }
  33
  34 namespace extensions {
  35
  36 class Extension;
  37
  38 namespace cookies_helpers {
  39
  40 typedef std::vector<linked_ptr<extensions::api::cookies::Cookie> >
  41     LinkedCookieVec;
  42
  43 // Returns either the original profile or the incognito profile, based on the
  44 // given store ID.  Returns NULL if the profile doesn't exist or is not allowed
  45 // (e.g. if incognito mode is not enabled for the extension).
  46 Profile* ChooseProfileFromStoreId(const std::string& store_id,
  47                                   Profile* profile,
  48                                   bool include_incognito);
  49
  50 // Returns the store ID for a particular user profile.
  51 const char* GetStoreIdFromProfile(Profile* profile);
  52
  53 // Allocates and construct a new Cookie object representing a cookie as defined
  54 // by the cookies API.
  55 scoped_ptr<extensions::api::cookies::Cookie> CreateCookie(
  56     const net::CanonicalCookie& cookie,
  57     const std::string& store_id);
  58
  59 // Allocates and constructs a new CookieStore object as defined by the cookies
  60 // API.
  61 scoped_ptr<extensions::api::cookies::CookieStore> CreateCookieStore(
  62     Profile* profile,
  63     base::ListValue* tab_ids);
  64
  65 // Retrieves all cookies from the given cookie store corresponding to the given
  66 // URL. If the URL is empty, all cookies in the cookie store are retrieved.
  67 // This can only be called on the IO thread.
  68 void GetCookieListFromStore(
  69     net::CookieStore* cookie_store, const GURL& url,
  70     const net::CookieMonster::GetCookieListCallback& callback);
  71
  72 // Constructs a URL from a cookie's information for use in checking
  73 // a cookie against the extension's host permissions. The Secure
  74 // property of the cookie defines the URL scheme, and the cookie's
  75 // domain becomes the URL host.
  76 GURL GetURLFromCanonicalCookie(
  77     const net::CanonicalCookie& cookie);
  78
  79 // Looks through all cookies in the given cookie store, and appends to the
  80 // match vector all the cookies that both match the given URL and cookie details
  81 // and are allowed by extension host permissions.
  82 void AppendMatchingCookiesToVector(
  83     const net::CookieList& all_cookies, const GURL& url,
  84     const extensions::api::cookies::GetAll::Params::Details* details,
  85     const Extension* extension, LinkedCookieVec* match_vector);
  86
  87 // Appends the IDs of all tabs belonging to the given browser to the
  88 // given list.
  89 void AppendToTabIdList(Browser* browser, base::ListValue* tab_ids);
  90
  91 // A class representing the cookie filter parameters passed into
  92 // cookies.getAll().
  93 // This class is essentially a convenience wrapper for the details dictionary
  94 // passed into the cookies.getAll() API by the user. If the dictionary contains
  95 // no filter parameters, the MatchFilter will always trivially
  96 // match all cookies.
  97 class MatchFilter {
  98  public:
  99   // Takes the details dictionary argument given by the user as input.
 100   // This class does not take ownership of the lifetime of the Details
 101   // object.
 102   explicit MatchFilter(
 103       const extensions::api::cookies::GetAll::Params::Details* details);
 104
 105   // Returns true if the given cookie matches the properties in the match
 106   // filter.
 107   bool MatchesCookie(const net::CanonicalCookie& cookie);
 108
 109  private:
 110   // Returns true if the given cookie domain string matches the filter's
 111   // domain. Any cookie domain which is equal to or is a subdomain of the
 112   // filter's domain will be matched; leading '.' characters indicating
 113   // host-only domains have no meaning in the match filter domain (for
 114   // instance, a match filter domain of 'foo.bar.com' will be treated the same
 115   // as '.foo.bar.com', and both will match cookies with domain values of
 116   // 'foo.bar.com', '.foo.bar.com', and 'baz.foo.bar.com'.
 117   bool MatchesDomain(const std::string& domain);
 118
 119   const extensions::api::cookies::GetAll::Params::Details* details_;
 120 };
 121
 122 }  // namespace cookies_helpers
 123 }  // namespace extensions
 124
 125 #endif  // CHROME_BROWSER_EXTENSIONS_API_COOKIES_COOKIES_HELPERS_H_