gdata: Make GDataCache::CacheEntry a struct

chrome/browser/chromeos/gdata/gdata_cache.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 CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_
 
 #include <map>
 #include <string>
 
@@ skipping 101 matching lines @@
                                  const std::string& md5) {}
 
     // Triggered when a dirty file has been committed (saved) successfully.
     virtual void OnCacheCommitted(const std::string& resource_id) {}
 
    protected:
     virtual ~Observer() {}
   };
 
   // Structure to store information of an existing cache file.
-  struct CacheEntry {
-    CacheEntry() : cache_state(CACHE_STATE_NONE) {}
+  class CacheEntry {
+   public:
+    CacheEntry() : cache_state_(CACHE_STATE_NONE) {}
 
     CacheEntry(const std::string& md5,
                int cache_state)
-        : md5(md5),
-          cache_state(cache_state) {
+        : md5_(md5),
+          cache_state_(cache_state) {
     }
 
+    // The MD5 of the cache file. This can be "local" if the file is
+    // locally modified.
+    const std::string& md5() const { return md5_; }
+
+    // The cache state represented as a bit-field of GDataCacheState.
+    int cache_state() const { return cache_state_; }
+
+    void set_md5(const std::string& md5) { md5_ = md5; }
+    void set_cache_state(int cache_state) { cache_state_ = cache_state; }
+
     // Returns true if the file is present locally.
-    bool IsPresent() const { return cache_state & CACHE_STATE_PRESENT; }
+    bool IsPresent() const { return cache_state_ & CACHE_STATE_PRESENT; }
 
     // Returns true if the file is pinned (i.e. available offline).
-    bool IsPinned() const { return cache_state & CACHE_STATE_PINNED; }
+    bool IsPinned() const { return cache_state_ & CACHE_STATE_PINNED; }
 
     // Returns true if the file is dirty (i.e. modified locally).
-    bool IsDirty() const { return cache_state & CACHE_STATE_DIRTY; }
+    bool IsDirty() const { return cache_state_ & CACHE_STATE_DIRTY; }
 
     // Returns true if the file is a mounted archive file.
-    bool IsMounted() const { return cache_state & CACHE_STATE_MOUNTED; }
+    bool IsMounted() const { return cache_state_ & CACHE_STATE_MOUNTED; }
 
     // Returns true if the file is in the persistent directory.
-    bool IsPersistent() const { return cache_state & CACHE_STATE_PERSISTENT; }
+    bool IsPersistent() const { return cache_state_ & CACHE_STATE_PERSISTENT; }
 
     // Setters for the states describe above.
     void SetPresent(bool value) {
       if (value)
-        cache_state |= CACHE_STATE_PRESENT;
+        cache_state_ |= CACHE_STATE_PRESENT;
       else
-        cache_state &= ~CACHE_STATE_PRESENT;
+        cache_state_ &= ~CACHE_STATE_PRESENT;
     }
     void SetPinned(bool value) {
       if (value)
-        cache_state |= CACHE_STATE_PINNED;
+        cache_state_ |= CACHE_STATE_PINNED;
       else
-        cache_state &= ~CACHE_STATE_PINNED;
+        cache_state_ &= ~CACHE_STATE_PINNED;
     }
     void SetDirty(bool value) {
       if (value)
-        cache_state |= CACHE_STATE_DIRTY;
+        cache_state_ |= CACHE_STATE_DIRTY;
       else
-        cache_state &= ~CACHE_STATE_DIRTY;
+        cache_state_ &= ~CACHE_STATE_DIRTY;
     }
     void SetMounted(bool value) {
       if (value)
-        cache_state |= CACHE_STATE_MOUNTED;
+        cache_state_ |= CACHE_STATE_MOUNTED;
       else
-        cache_state &= ~CACHE_STATE_MOUNTED;
+        cache_state_ &= ~CACHE_STATE_MOUNTED;
     }
     void SetPersistent(bool value) {
       if (value)
-        cache_state |= CACHE_STATE_PERSISTENT;
+        cache_state_ |= CACHE_STATE_PERSISTENT;
       else
-        cache_state &= ~CACHE_STATE_PERSISTENT;
+        cache_state_ &= ~CACHE_STATE_PERSISTENT;
     }
 
     // Returns the type of the sub directory where the cache file is stored.
     CacheSubDirectoryType GetSubDirectoryType() const {
       return IsPersistent() ? CACHE_TYPE_PERSISTENT : CACHE_TYPE_TMP;
     }
 
     // For debugging purposes.
     std::string ToString() const;
 
-    std::string md5;
-    int cache_state;
+   private:
+    std::string md5_;
+    int cache_state_;
   };
 
   // Callback for GetCacheEntryOnUIThread.
   // |success| indicates if the operation was successful.
   // |cache_entry| is the obtained cache entry. On failure, |cache_state| is
   // set to CACHE_STATE_NONE.
   //
   // TODO(satorux): Unlike other callback types, this has to be defined
   // inside GDataCache as CacheEntry is inside GDataCache. We should get them
   // outside of GDataCache.
@@ skipping 315 matching lines @@
 };
 
 // Sets the free disk space getter for testing.
 // The existing getter is deleted.
 void SetFreeDiskSpaceGetterForTesting(
     FreeDiskSpaceGetterInterface* getter);
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_CACHE_H_