Home | History | Annotate | Download | only in common 
      1 // Copyright 2013 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 #ifndef CHROME_BROWSER_UI_APP_LIST_SEARCH_COMMON_WEBSERVICE_CACHE_H_
      6 #define CHROME_BROWSER_UI_APP_LIST_SEARCH_COMMON_WEBSERVICE_CACHE_H_
      7 
      8 #include <utility>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/containers/mru_cache.h"
     12 #include "base/memory/ref_counted.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "base/time/time.h"
     15 #include "chrome/browser/ui/app_list/search/common/dictionary_data_store.h"
     16 #include "components/keyed_service/core/keyed_service.h"
     17 
     18 namespace base {
     19 class DictionaryValue;
     20 }
     21 
     22 namespace content {
     23 class BrowserContext;
     24 }
     25 
     26 namespace app_list {
     27 
     28 enum ResultStatus {
     29   FRESH = 0,
     30   STALE = 1
     31 };
     32 
     33 // Pair of values, first indicating whether this is a fresh result or stale,
     34 // the second holding the actual value.
     35 typedef std::pair<ResultStatus, const base::DictionaryValue*> CacheResult;
     36 
     37 // WebserviceCache manages a cache of search results which should be valid
     38 // during an input session. This will reduce unnecessary queries for typing
     39 // backspace or so on. This is not meant to hold cache entries across multiple
     40 // search sessions.
     41 class WebserviceCache : public KeyedService,
     42                         public base::SupportsWeakPtr<WebserviceCache> {
     43  public:
     44   enum QueryType {
     45     WEBSTORE = 0,
     46     PEOPLE = 1
     47   };
     48 
     49   explicit WebserviceCache(content::BrowserContext* context);
     50   virtual ~WebserviceCache();
     51 
     52   // Checks the current cache and returns the value for the |query| if it's
     53   // valid. Otherwise an CacheResult object with the result field set to NULL.
     54   // A query consists of a query 'type' and the query itself. The two current
     55   // types of queries supported are webstore queries and people search queries.
     56   // The type silos the query into it's own separate domain, preventing any
     57   // mixing of the queries.
     58   const CacheResult Get(QueryType type, const std::string& query);
     59 
     60   // Puts the new result to the query.
     61   void Put(QueryType type,
     62            const std::string& query,
     63            scoped_ptr<base::DictionaryValue> result);
     64 
     65  private:
     66   struct Payload {
     67     Payload(const base::Time& time,
     68             const base::DictionaryValue* result)
     69         : time(time), result(result) {}
     70     Payload() {}
     71 
     72     base::Time time;
     73     const base::DictionaryValue* result;
     74   };
     75 
     76   class CacheDeletor {
     77    public:
     78     void operator()(Payload& payload);
     79   };
     80   typedef base::MRUCacheBase<std::string, Payload, CacheDeletor> Cache;
     81 
     82   // Callback for when the cache is loaded from the dictionary data store.
     83   void OnCacheLoaded(scoped_ptr<base::DictionaryValue>);
     84 
     85   // Populates the payload parameter with the corresponding payload stored
     86   // in the given dictionary. If the dictionary is invalid for any reason,
     87   // this method will return false.
     88   bool PayloadFromDict(const base::DictionaryValue* dict,
     89                        Payload* payload);
     90 
     91   // Returns a dictionary value for a given payload. The returned dictionary
     92   // will be owned by the data_store_ cached_dict, and freed on the destruction
     93   // of our dictionary datastore.
     94   base::DictionaryValue* DictFromPayload(const Payload& payload);
     95 
     96   // Trims our MRU cache, making sure that any element that is removed is also
     97   // removed from the dictionary data store.
     98   void TrimCache();
     99 
    100   // Prepends a type string to the given query and returns a new query string.
    101   std::string PrependType(QueryType type, const std::string& query);
    102 
    103   Cache cache_;
    104   scoped_refptr<DictionaryDataStore> data_store_;
    105 
    106   bool cache_loaded_;
    107 
    108   DISALLOW_COPY_AND_ASSIGN(WebserviceCache);
    109 };
    110 
    111 }  // namespace app_list
    112 
    113 #endif  // CHROME_BROWSER_UI_APP_LIST_SEARCH_COMMON_WEBSERVICE_CACHE_H_
    114