Home | History | Annotate | Download | only in lib 
      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 #ifndef RLZ_VALUE_STORE_H_
      6 #define RLZ_VALUE_STORE_H_
      7 
      8 #include "base/basictypes.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "rlz/lib/rlz_enums.h"
     11 
     12 #if defined(OS_WIN)
     13 #include "rlz/win/lib/lib_mutex.h"
     14 #endif
     15 
     16 #if defined(OS_MACOSX)
     17 #include "base/mac/scoped_nsautorelease_pool.h"
     18 #endif
     19 
     20 
     21 #include <string>
     22 #include <vector>
     23 
     24 namespace base {
     25 class FilePath;
     26 }
     27 
     28 namespace rlz_lib {
     29 
     30 // Abstracts away rlz's key value store. On windows, this usually writes to
     31 // the registry. On mac, it writes to an NSDefaults object.
     32 class RlzValueStore {
     33  public:
     34   virtual ~RlzValueStore() {}
     35 
     36   enum AccessType { kReadAccess, kWriteAccess };
     37   virtual bool HasAccess(AccessType type) = 0;
     38 
     39   // Ping times.
     40   virtual bool WritePingTime(Product product, int64 time) = 0;
     41   virtual bool ReadPingTime(Product product, int64* time) = 0;
     42   virtual bool ClearPingTime(Product product) = 0;
     43 
     44   // Access point RLZs.
     45   virtual bool WriteAccessPointRlz(AccessPoint access_point,
     46                                    const char* new_rlz) = 0;
     47   virtual bool ReadAccessPointRlz(AccessPoint access_point,
     48                                   char* rlz,  // At most kMaxRlzLength + 1 bytes
     49                                   size_t rlz_size) = 0;
     50   virtual bool ClearAccessPointRlz(AccessPoint access_point) = 0;
     51 
     52   // Product events.
     53   // Stores |event_rlz| for product |product| as product event.
     54   virtual bool AddProductEvent(Product product, const char* event_rlz) = 0;
     55   // Appends all events for |product| to |events|, in arbirtrary order.
     56   virtual bool ReadProductEvents(Product product,
     57                                  std::vector<std::string>* events) = 0;
     58   // Removes the stored event |event_rlz| for |product| if it exists.
     59   virtual bool ClearProductEvent(Product product, const char* event_rlz) = 0;
     60   // Removes all stored product events for |product|.
     61   virtual bool ClearAllProductEvents(Product product) = 0;
     62 
     63   // Stateful events.
     64   // Stores |event_rlz| for product |product| as stateful event.
     65   virtual bool AddStatefulEvent(Product product, const char* event_rlz) = 0;
     66   // Checks if |event_rlz| has been stored as stateful event for |product|.
     67   virtual bool IsStatefulEvent(Product product, const char* event_rlz) = 0;
     68   // Removes all stored stateful events for |product|.
     69   virtual bool ClearAllStatefulEvents(Product product) = 0;
     70 
     71   // Tells the value store to clean up unimportant internal data structures, for
     72   // example empty registry folders, that might remain after clearing other
     73   // data. Best-effort.
     74   virtual void CollectGarbage() = 0;
     75 };
     76 
     77 // All methods of RlzValueStore must stays consistent even when accessed from
     78 // multiple threads in multiple processes. To enforce this through the type
     79 // system, the only way to access the RlzValueStore is through a
     80 // ScopedRlzValueStoreLock, which is a cross-process lock. It is active while
     81 // it is in scope. If the class fails to acquire a lock, its GetStore() method
     82 // returns NULL. If the lock fails to be acquired, it must not be taken
     83 // recursively. That is, all user code should look like this:
     84 //   ScopedRlzValueStoreLock lock;
     85 //   RlzValueStore* store = lock.GetStore();
     86 //   if (!store)
     87 //     return some_error_code;
     88 //   ...
     89 class ScopedRlzValueStoreLock {
     90  public:
     91   ScopedRlzValueStoreLock();
     92   ~ScopedRlzValueStoreLock();
     93 
     94   // Returns a RlzValueStore protected by a cross-process lock, or NULL if the
     95   // lock can't be obtained. The lifetime of the returned object is limited to
     96   // the lifetime of this ScopedRlzValueStoreLock object.
     97   RlzValueStore* GetStore();
     98 
     99  private:
    100   scoped_ptr<RlzValueStore> store_;
    101 #if defined(OS_WIN)
    102   LibMutex lock_;
    103 #elif defined(OS_MACOSX)
    104   base::mac::ScopedNSAutoreleasePool autorelease_pool_;
    105 #endif
    106 };
    107 
    108 #if defined(OS_POSIX)
    109 namespace testing {
    110 // Prefix |directory| to the path where the RLZ data file lives, for tests.
    111 void SetRlzStoreDirectory(const base::FilePath& directory);
    112 
    113 // Returns the path of the file used as data store.
    114 std::string RlzStoreFilenameStr();
    115 }  // namespace testing
    116 #endif  // defined(OS_POSIX)
    117 
    118 }  // namespace rlz_lib
    119 
    120 #endif  // RLZ_VALUE_STORE_H_
    121