[cros] RlzValueStore implementation for ChromeOS.

rlz/chromeos/lib/rlz_value_store_chromeos.h

 // 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_MAC_LIB_RLZ_VALUE_STORE_MAC_H_
-#define RLZ_MAC_LIB_RLZ_VALUE_STORE_MAC_H_
+#ifndef RLZ_CHROMEOS_LIB_RLZ_VALUE_STORE_CHROMEOS_H_
+#define RLZ_CHROMEOS_LIB_RLZ_VALUE_STORE_CHROMEOS_H_
 
+#include "base/prefs/persistent_pref_store.h"
+#include "base/threading/non_thread_safe.h"
 #include "rlz/lib/rlz_value_store.h"
-#include "base/compiler_specific.h"
-#include "base/memory/scoped_nsobject.h"
 
-@class NSDictionary;
-@class NSMutableDictionary;
+namespace base {
+class ListValue;
+class MessageLoopProxy;
+class Value;
+}
+
+template <typename T> struct DefaultSingletonTraits;
 
 namespace rlz_lib {
 
-// An implementation of RlzValueStore for mac. It stores information in a
-// plist file in the user's Application Support folder.
-class RlzValueStoreMac : public RlzValueStore {
+// An implementation of RlzValueStore for ChromeOS. Unlike Mac and Win
+// counterparts, it's non thread-safe and should only be accessed on a single
+// Thread instance that has a MessageLoop.

[Roger Tawa OOO till Jul 10th, 2012/11/06 20:55:11]

Why is that a valid assumption?  I don't believe it is.  The rlz api is called
from the ui thread and the blocking poll thread.

[Ivan Korotkov, 2012/11/07 10:49:12]

Yes, currently RlzValueStore is accessed on a blocking SequencedWorkerPool
(which uses SimpleThreads w/o a MessageLoop).

The tricky part is, JsonPrefStore havily relies on (1) having a valid
ThreadTaskRunnerHandle, which requires a MessageLoop and (2) being always called
on the same thread.

So on ChromeOS, I'm going to run RLZ code on a dedicated Thread instead of
blocking pool. This shouldn't change anything in terms of performace, since it's
a SequencedWorkerPool anyway, right?

Actually, if that's OK with you, it'd be simpler to not create different
versions of code and introduce this dedicated thread on Win/Mac as well.

+class RlzValueStoreChromeOS : public RlzValueStore,
+                              public base::NonThreadSafe {
  public:
+  static RlzValueStoreChromeOS* GetInstance();
+
+  // Sets the MessageLoopProxy that underlying PersistentPrefStore will post I/O
+  // tasks to. Must be called before the first GetInstance() call.
+  static void SetIOTaskRunner(base::MessageLoopProxy* io_task_runner);
+
+  // RlzValueStore overrides:
   virtual bool HasAccess(AccessType type) OVERRIDE;
 
   virtual bool WritePingTime(Product product, int64 time) OVERRIDE;
   virtual bool ReadPingTime(Product product, int64* time) OVERRIDE;
   virtual bool ClearPingTime(Product product) OVERRIDE;
 
   virtual bool WriteAccessPointRlz(AccessPoint access_point,
                                    const char* new_rlz) OVERRIDE;
   virtual bool ReadAccessPointRlz(AccessPoint access_point,
                                   char* rlz,
                                   size_t rlz_size) OVERRIDE;
   virtual bool ClearAccessPointRlz(AccessPoint access_point) OVERRIDE;
 
   virtual bool AddProductEvent(Product product, const char* event_rlz) OVERRIDE;
   virtual bool ReadProductEvents(Product product,
                                  std::vector<std::string>* events) OVERRIDE;
   virtual bool ClearProductEvent(Product product,
                                  const char* event_rlz) OVERRIDE;
   virtual bool ClearAllProductEvents(Product product) OVERRIDE;
 
   virtual bool AddStatefulEvent(Product product,
                                 const char* event_rlz) OVERRIDE;
   virtual bool IsStatefulEvent(Product product,
                                const char* event_rlz) OVERRIDE;
   virtual bool ClearAllStatefulEvents(Product product) OVERRIDE;
 
   virtual void CollectGarbage() OVERRIDE;
 
  private:
-  // |dict| is the dictionary that backs all data. plist_path is the name of the
-  // plist file, used solely for implementing HasAccess().
-  RlzValueStoreMac(NSMutableDictionary* dict, NSString* plist_path);
-  virtual ~RlzValueStoreMac();
-  friend class ScopedRlzValueStoreLock;
+  friend struct DefaultSingletonTraits<RlzValueStoreChromeOS>;
 
-  // Returns the backing dictionary that should be written to disk.
-  NSDictionary* dictionary();
+  // Used by JsonPrefStore to schedule write operations.
+  static base::MessageLoopProxy* io_task_runner_;
 
-  // Returns the dictionary to which all data should be written. Usually, this
-  // is just |dictionary()|, but if supplementary branding is used, it's a
-  // subdirectory at key "brand_<supplementary branding code>".
-  // Note that windows stores data at
-  //    rlz/name (e.g. "pingtime")/supplementalbranding/productcode
-  // Mac on the other hand does
-  //    supplementalbranding/productcode/pingtime.
-  NSMutableDictionary* WorkingDict();
+  RlzValueStoreChromeOS();
+  virtual ~RlzValueStoreChromeOS();
 
-  // Returns the subdirectory of |WorkingDict()| used to store data for
-  // product p.
-  NSMutableDictionary* ProductDict(Product p);
+  // Retrieves list at path |list_name| from JSON store.
+  base::ListValue* GetList(std::string list_name);
+  // Adds |value| to list at |list_name| path in JSON store.
+  bool AddValueToList(std::string list_name, base::Value* value);
+  // Removes |value| from list at |list_name| path in JSON store.
+  bool RemoveValueFromList(std::string list_name, const base::Value& value);
 
-  scoped_nsobject<NSMutableDictionary> dict_;
-  scoped_nsobject<NSString> plist_path_;
+  // Store with RLZ data.
+  scoped_refptr<PersistentPrefStore> rlz_store_;
 
-  DISALLOW_COPY_AND_ASSIGN(RlzValueStoreMac);
+  DISALLOW_COPY_AND_ASSIGN(RlzValueStoreChromeOS);
 };
 
 }  // namespace rlz_lib
 
-#endif  // RLZ_MAC_LIB_RLZ_VALUE_STORE_MAC_H_
+#endif  // RLZ_CHROMEOS_LIB_RLZ_VALUE_STORE_CHROMEOS_H_