summaryrefslogtreecommitdiffstats
path: root/rlz/lib/rlz_value_store.h
blob: 4bd1f093b83af5110556f65d0cb379a0c127d913 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
// Copyright (c) 2012 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.

#ifndef RLZ_VALUE_STORE_H_
#define RLZ_VALUE_STORE_H_

#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "rlz/lib/rlz_enums.h"

#if defined(OS_WIN)
#include "rlz/win/lib/lib_mutex.h"
#endif

#if defined(OS_MACOSX)
#include "base/mac/scoped_nsautorelease_pool.h"
#endif


#include <string>
#include <vector>

namespace base {
class FilePath;
}

namespace rlz_lib {

// Abstracts away rlz's key value store. On windows, this usually writes to
// the registry. On mac, it writes to an NSDefaults object.
class RlzValueStore {
 public:
  virtual ~RlzValueStore() {}

  enum AccessType { kReadAccess, kWriteAccess };
  virtual bool HasAccess(AccessType type) = 0;

  // Ping times.
  virtual bool WritePingTime(Product product, int64 time) = 0;
  virtual bool ReadPingTime(Product product, int64* time) = 0;
  virtual bool ClearPingTime(Product product) = 0;

  // Access point RLZs.
  virtual bool WriteAccessPointRlz(AccessPoint access_point,
                                   const char* new_rlz) = 0;
  virtual bool ReadAccessPointRlz(AccessPoint access_point,
                                  char* rlz,  // At most kMaxRlzLength + 1 bytes
                                  size_t rlz_size) = 0;
  virtual bool ClearAccessPointRlz(AccessPoint access_point) = 0;

  // Product events.
  // Stores |event_rlz| for product |product| as product event.
  virtual bool AddProductEvent(Product product, const char* event_rlz) = 0;
  // Appends all events for |product| to |events|, in arbirtrary order.
  virtual bool ReadProductEvents(Product product,
                                 std::vector<std::string>* events) = 0;
  // Removes the stored event |event_rlz| for |product| if it exists.
  virtual bool ClearProductEvent(Product product, const char* event_rlz) = 0;
  // Removes all stored product events for |product|.
  virtual bool ClearAllProductEvents(Product product) = 0;

  // Stateful events.
  // Stores |event_rlz| for product |product| as stateful event.
  virtual bool AddStatefulEvent(Product product, const char* event_rlz) = 0;
  // Checks if |event_rlz| has been stored as stateful event for |product|.
  virtual bool IsStatefulEvent(Product product, const char* event_rlz) = 0;
  // Removes all stored stateful events for |product|.
  virtual bool ClearAllStatefulEvents(Product product) = 0;

  // Tells the value store to clean up unimportant internal data structures, for
  // example empty registry folders, that might remain after clearing other
  // data. Best-effort.
  virtual void CollectGarbage() = 0;
};

// All methods of RlzValueStore must stays consistent even when accessed from
// multiple threads in multiple processes. To enforce this through the type
// system, the only way to access the RlzValueStore is through a
// ScopedRlzValueStoreLock, which is a cross-process lock. It is active while
// it is in scope. If the class fails to acquire a lock, its GetStore() method
// returns NULL. If the lock fails to be acquired, it must not be taken
// recursively. That is, all user code should look like this:
//   ScopedRlzValueStoreLock lock;
//   RlzValueStore* store = lock.GetStore();
//   if (!store)
//     return some_error_code;
//   ...
class ScopedRlzValueStoreLock {
 public:
  ScopedRlzValueStoreLock();
  ~ScopedRlzValueStoreLock();

  // Returns a RlzValueStore protected by a cross-process lock, or NULL if the
  // lock can't be obtained. The lifetime of the returned object is limited to
  // the lifetime of this ScopedRlzValueStoreLock object.
  RlzValueStore* GetStore();

 private:
  scoped_ptr<RlzValueStore> store_;
#if defined(OS_WIN)
  LibMutex lock_;
#elif defined(OS_MACOSX)
  base::mac::ScopedNSAutoreleasePool autorelease_pool_;
#endif
};

#if defined(OS_POSIX)
namespace testing {
// Prefix |directory| to the path where the RLZ data file lives, for tests.
void SetRlzStoreDirectory(const base::FilePath& directory);

// Returns the path of the file used as data store.
std::string RlzStoreFilenameStr();
}  // namespace testing
#endif  // defined(OS_POSIX)

}  // namespace rlz_lib

#endif  // RLZ_VALUE_STORE_H_