// Copyright (c) 2009 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_SYNC_SYNCABLE_SYNCABLE_H_
#define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_

#include <algorithm>
#include <bitset>
#include <iosfwd>
#include <map>
#include <set>
#include <string>
#include <vector>

#include "base/atomicops.h"
#include "base/basictypes.h"
#include "base/time.h"
#include "chrome/browser/sync/syncable/blob.h"
#include "chrome/browser/sync/syncable/dir_open_result.h"
#include "chrome/browser/sync/syncable/directory_event.h"
#include "chrome/browser/sync/syncable/path_name_cmp.h"
#include "chrome/browser/sync/syncable/syncable_id.h"
#include "chrome/browser/sync/util/compat_file.h"
#include "chrome/browser/sync/util/compat_pthread.h"
#include "chrome/browser/sync/util/dbgq.h"
#include "chrome/browser/sync/util/event_sys.h"
#include "chrome/browser/sync/util/path_helpers.h"
#include "chrome/browser/sync/util/pthread_helpers.h"
#include "chrome/browser/sync/util/row_iterator.h"
#include "chrome/browser/sync/util/sync_types.h"

struct PurgeInfo;

namespace sync_api {
class ReadTransaction;
class WriteNode;
class ReadNode;
}

namespace syncable {
class Entry;
}

std::ostream& operator<<(std::ostream& s, const syncable::Entry& e);

namespace syncable {

class DirectoryBackingStore;

static const int64 kInvalidMetaHandle = 0;

enum {
  BEGIN_FIELDS = 0,
  INT64_FIELDS_BEGIN = BEGIN_FIELDS
};

enum MetahandleField {
  // Primary key into the table.  Keep this as a handle to the meta entry
  // across transactions.
  META_HANDLE = INT64_FIELDS_BEGIN
};

enum BaseVersion {
  // After initial upload, the version is controlled by the server, and is
  // increased whenever the data or metadata changes on the server.
  BASE_VERSION = META_HANDLE + 1,
};

enum Int64Field {
  SERVER_VERSION = BASE_VERSION + 1,
  MTIME,
  SERVER_MTIME,
  CTIME,
  SERVER_CTIME,

  // A numeric position value that indicates the relative ordering of
  // this object among its siblings.
  SERVER_POSITION_IN_PARENT,

  LOCAL_EXTERNAL_ID,  // ID of an item in the external local storage that this
                      // entry is associated with. (such as bookmarks.js)

  INT64_FIELDS_END
};

enum {
  INT64_FIELDS_COUNT = INT64_FIELDS_END,
  ID_FIELDS_BEGIN = INT64_FIELDS_END,
};

enum IdField {
  // Code in InitializeTables relies on ID being the first IdField value.
  ID = ID_FIELDS_BEGIN,
  PARENT_ID,
  SERVER_PARENT_ID,

  PREV_ID,
  NEXT_ID,
  ID_FIELDS_END
};

enum {
  ID_FIELDS_COUNT = ID_FIELDS_END - ID_FIELDS_BEGIN,
  BIT_FIELDS_BEGIN = ID_FIELDS_END
};

enum IndexedBitField {
  IS_UNSYNCED = BIT_FIELDS_BEGIN,
  IS_UNAPPLIED_UPDATE,
  INDEXED_BIT_FIELDS_END,
};

enum IsDelField {
  IS_DEL = INDEXED_BIT_FIELDS_END,
};

enum BitField {
  IS_DIR = IS_DEL + 1,
  IS_BOOKMARK_OBJECT,

  SERVER_IS_DIR,
  SERVER_IS_DEL,
  SERVER_IS_BOOKMARK_OBJECT,

  BIT_FIELDS_END
};

enum {
  BIT_FIELDS_COUNT = BIT_FIELDS_END - BIT_FIELDS_BEGIN,
  STRING_FIELDS_BEGIN = BIT_FIELDS_END
};

enum StringField {
  // The name, transformed so as to be suitable for use as a path-element.  It
  // is unique, and legal for this client.
  NAME = STRING_FIELDS_BEGIN,
  // The local name, pre-sanitization.  It is not necessarily unique.  If this
  // is empty, it means |NAME| did not require sanitization.
  UNSANITIZED_NAME,
  // If NAME/UNSANITIZED_NAME are "Foo (2)", then NON_UNIQUE_NAME may be "Foo".
  NON_UNIQUE_NAME,
  // The server version of |NAME|.  It is uniquified, but not necessarily
  // OS-legal.
  SERVER_NAME,
  // The server version of |NON_UNIQUE_NAME|.  Again, if SERVER_NAME is
  // like "Foo (2)" due to a commit-time name aside, SERVER_NON_UNIQUE_NAME
  // may hold the value "Foo".
  SERVER_NON_UNIQUE_NAME,
  // For bookmark entries, the URL of the bookmark.
  BOOKMARK_URL,
  SERVER_BOOKMARK_URL,

  // A tag string which identifies this node as a particular top-level
  // permanent object.  The tag can be thought of as a unique key that
  // identifies a singleton instance.
  SINGLETON_TAG,
  STRING_FIELDS_END,
};

enum {
  STRING_FIELDS_COUNT = STRING_FIELDS_END - STRING_FIELDS_BEGIN,
  BLOB_FIELDS_BEGIN = STRING_FIELDS_END
};

// From looking at the sqlite3 docs, it's not directly stated, but it
// seems the overhead for storing a NULL blob is very small.
enum BlobField {
  // For bookmark entries, the favicon data.  These will be NULL for
  // non-bookmark items.
  BOOKMARK_FAVICON = BLOB_FIELDS_BEGIN,
  SERVER_BOOKMARK_FAVICON,
  BLOB_FIELDS_END,
};

enum {
  BLOB_FIELDS_COUNT = BLOB_FIELDS_END - BLOB_FIELDS_BEGIN
};

enum {
  FIELD_COUNT = BLOB_FIELDS_END,
  // Past this point we have temporaries, stored in memory only.
  BEGIN_TEMPS = BLOB_FIELDS_END,
  BIT_TEMPS_BEGIN = BEGIN_TEMPS,
};

enum BitTemp {
  SYNCING = BIT_TEMPS_BEGIN,
  IS_NEW,  // Means use INSERT instead of UPDATE to save to db.
  DEPRECATED_DELETE_ON_CLOSE,  // Set by redirector, IS_OPEN must also be set.
  DEPRECATED_CHANGED_SINCE_LAST_OPEN,  // Have we been written to since we've
                                       // been opened.
  BIT_TEMPS_END,
};

enum {
  BIT_TEMPS_COUNT = BIT_TEMPS_END - BIT_TEMPS_BEGIN
};

class BaseTransaction;
class WriteTransaction;
class ReadTransaction;
class Directory;
class ScopedDirLookup;
class ExtendedAttribute;

// Instead of:
//   Entry e = transaction.GetById(id);
// use:
//   Entry e(transaction, GET_BY_ID, id);
//
// Why?  The former would require a copy constructor, and it would be difficult
// to enforce that an entry never outlived its transaction if there were a copy
// constructor.
enum GetById {
  GET_BY_ID
};

enum GetByTag {
  GET_BY_TAG
};

enum GetByHandle {
  GET_BY_HANDLE
};

enum GetByPath {
  GET_BY_PATH
};

enum GetByParentIdAndName {
  GET_BY_PARENTID_AND_NAME
};

// DBName is the name stored in the database.
enum GetByParentIdAndDBName {
  GET_BY_PARENTID_AND_DBNAME
};

enum Create {
  CREATE
};

enum CreateNewUpdateItem {
  CREATE_NEW_UPDATE_ITEM
};

typedef std::set<PathString> AttributeKeySet;

// DBName is a PathString with additional transformation methods that are
// useful when trying to derive a unique and legal database name from an
// unsanitized sync name.
class DBName : public PathString {
 public:
  explicit DBName(const PathString& database_name)
      : PathString(database_name) { }

  // TODO(ncarter): Remove these codepaths to maintain alternate titles which
  // are OS legal filenames, Chrome doesn't depend on this like some other
  // browsers do.
  void MakeOSLegal() {
    PathString new_value = MakePathComponentOSLegal(*this);
    if (!new_value.empty())
      swap(new_value);
  }

  // Modify the value of this DBName so that it is not in use by any entry
  // inside |parent_id|, except maybe |e|.  |e| may be NULL if you are trying
  // to compute a name for an entry which has yet to be created.
  void MakeNoncollidingForEntry(BaseTransaction* trans,
                                const Id& parent_id,
                                Entry* e);
};

// SyncName encapsulates a canonical server name.  In general, when we need to
// muck around with a name that the server sends us (e.g. to make it OS legal),
// we try to preserve the original value in a SyncName,
// and distill the new local value into a DBName.
// At other times, we need to apply transforms in the
// other direction -- that is, to create a server-appropriate SyncName from a
// user-updated DBName (which is an OS legal name, but not necessarily in the
// format that the server wants it to be).  For that sort of thing, you should
// initialize a SyncName from the DB name value, and use the methods of
// SyncName to canonicalize it.  At other times, you have a pair of canonical
// server values -- one (the "value") which is unique in the parent, and another
// (the "non unique value") which is not unique in the parent -- and you
// simply want to create a SyncName to hold them as a pair.
class SyncName {
 public:
  // Create a SyncName with the initially specified value.
  explicit SyncName(const PathString& sync_name)
      : value_(sync_name), non_unique_value_(sync_name) { }

  // Create a SyncName by specifying a value and a non-unique value.  If
  // you use this constructor, the values you provide should already be
  // acceptable server names.  Don't use the mutation/sanitization methods
  // on the resulting instance -- mutation won't work if you have distinct
  // values for the unique and non-unique fields.
  SyncName(const PathString& unique_sync_name,
           const PathString& non_unique_sync_name)
      : value_(unique_sync_name), non_unique_value_(non_unique_sync_name) { }

#ifdef OS_MACOSX
  // Translate [':' -> '/'] within the sync name.  Used on OSX.
  void ConvertColonsToSlashes() {
    DCHECK_EQ(value_, non_unique_value_)
        << "Deriving value_ will overwrite non_unique_value_.";
    std::string temporary_copy;
    temporary_copy.reserve(value_.size());
    StringReplace(value_, ":", "/", true, &temporary_copy);
    value_.swap(temporary_copy);
    non_unique_value_ = value_;
  }
#endif

  // Transform |value_| so that it's a legal server name.
  void MakeServerLegal() {
    DCHECK_EQ(value_, non_unique_value_)
        << "Deriving value_ will overwrite non_unique_value_.";
    // Append a trailing space if the value is one of the server's three
    // forbidden special cases.
    if (value_.empty() ||
        value_ == PSTR(".") ||
        value_ == PSTR("..")) {
      value_.append(PSTR(" "));
      non_unique_value_ = value_;
    }
    // TODO(ncarter): Handle server's other requirement: truncation to 256
    // bytes in Unicode NFC.
  }

  const PathString& value() const { return value_; }
  PathString& value() { return value_; }
  const PathString& non_unique_value() const { return non_unique_value_; }
  PathString& non_unique_value() { return non_unique_value_; }

  inline bool operator==(const SyncName& right_hand_side) const {
    return value_ == right_hand_side.value_ &&
        non_unique_value_ == right_hand_side.non_unique_value_;
  }
  inline bool operator!=(const SyncName& right_hand_side) const {
    return !(*this == right_hand_side);
  }
 private:
  PathString value_;
  PathString non_unique_value_;
};

// Name is a SyncName which has an additional DBName that provides a way to
// interpolate the "unsanitized name" according to the syncable convention.
//
// A method might accept a Name as an parameter when the sync and database
// names need to be set simultaneously:
//
//    void PutName(const Name& new_name) {
//       Put(NAME, new_name.db_value());
//       Put(UNSANITIZED_NAME, new_name.GetUnsanitizedName());
//    }
//
// A code point that is trying to convert between local database names and
// server sync names can use Name to help with the conversion:
//
//    SyncName server_name = entry->GetServerName();
//    Name name = Name::FromSyncName(server_name);  // Initially, name.value()
//                                                  // and name.db_value() are
//                                                  // equal to
//                                                  // server_name.value().
//    name.db_value().MakeOSLegal();  // Updates name.db_value in-place,
//                                    // leaving name.value() unchanged.
//    foo->PutName(name);
//
class Name : public SyncName {
 public:
  // Create a Name with an initially specified db_value and value.
  Name(const PathString& db_name, const PathString& sync_name)
      : SyncName(sync_name), db_value_(db_name) { }

  // Create a Name by specifying the db name, sync name, and non-unique
  // sync name values.
  Name(const PathString& db_name, const PathString& sync_name,
       const PathString& non_unique_sync_name)
      : SyncName(sync_name, non_unique_sync_name), db_value_(db_name) { }

  // Create a Name with all name values initially equal to the the single
  // specified argument.
  explicit Name(const PathString& sync_and_db_name)
      : SyncName(sync_and_db_name), db_value_(sync_and_db_name) { }

  // Create a Name using the local (non-SERVER) fields of an EntryKernel.
  static Name FromEntryKernel(struct EntryKernel*);

  // Create a Name from a SyncName.  db_value is initially sync_name.value().
  // non_unique_value() and value() are copied from |sync_name|.
  static Name FromSyncName(const SyncName& sync_name) {
    return Name(sync_name.value(), sync_name.value(),
                sync_name.non_unique_value());
  }

  static Name FromDBNameAndSyncName(const PathString& db_name,
                                    const SyncName& sync_name) {
    return Name(db_name, sync_name.value(), sync_name.non_unique_value());
  }

  // Get the database name.  The non-const version is useful for in-place
  // mutation.
  const DBName& db_value() const { return db_value_; }
  DBName& db_value() { return db_value_; }

  // Do the sync names and database names differ?  This indicates that
  // the sync name has been sanitized, and that GetUnsanitizedName() will
  // be non-empty.
  bool HasBeenSanitized() const { return db_value_ != value(); }

  // Compute the value of the unsanitized name from the current sync and db
  // name values.  The unsanitized name is the sync name value, unless the sync
  // name is the same as the db name value, in which case the unsanitized name
  // is empty.
  PathString GetUnsanitizedName() const {
    return HasBeenSanitized() ? value() : PathString();
  }

  inline bool operator==(const Name& right_hand_side) const {
    return this->SyncName::operator==(right_hand_side) &&
        db_value_ == right_hand_side.db_value_;
  }
  inline bool operator!=(const Name& right_hand_side) const {
    return !(*this == right_hand_side);
  }

 private:
  // The database name, which is maintained to be a legal and unique-in-parent
  // name.
  DBName db_value_;
};

// Why the singular enums?  So the code compile-time dispatches instead of
// runtime dispatches as it would with a single enum and an if() statement.

// The EntryKernel class contains the actual data for an entry.  It
// would be a private class, except the number of required friend
// declarations would bloat the code.
struct EntryKernel {
 protected:
  PathString string_fields[STRING_FIELDS_COUNT];
  Blob blob_fields[BLOB_FIELDS_COUNT];
  int64 int64_fields[INT64_FIELDS_COUNT];
  Id id_fields[ID_FIELDS_COUNT];
  std::bitset<BIT_FIELDS_COUNT> bit_fields;
  std::bitset<BIT_TEMPS_COUNT> bit_temps;

 public:
  std::bitset<FIELD_COUNT> dirty;

  // Contain all this error-prone arithmetic in one place.
  inline int64& ref(MetahandleField field) {
    return int64_fields[field - INT64_FIELDS_BEGIN];
  }
  inline int64& ref(Int64Field field) {
    return int64_fields[field - INT64_FIELDS_BEGIN];
  }
  inline Id& ref(IdField field) {
    return id_fields[field - ID_FIELDS_BEGIN];
  }
  inline int64& ref(BaseVersion field) {
    return int64_fields[field - INT64_FIELDS_BEGIN];
  }
  inline std::bitset<BIT_FIELDS_COUNT>::reference ref(IndexedBitField field) {
    return bit_fields[field - BIT_FIELDS_BEGIN];
  }
  inline std::bitset<BIT_FIELDS_COUNT>::reference ref(IsDelField field) {
    return bit_fields[field - BIT_FIELDS_BEGIN];
  }
  inline std::bitset<BIT_FIELDS_COUNT>::reference ref(BitField field) {
    return bit_fields[field - BIT_FIELDS_BEGIN];
  }
  inline PathString& ref(StringField field) {
    return string_fields[field - STRING_FIELDS_BEGIN];
  }
  inline Blob& ref(BlobField field) {
    return blob_fields[field - BLOB_FIELDS_BEGIN];
  }
  inline std::bitset<BIT_TEMPS_COUNT>::reference ref(BitTemp field) {
    return bit_temps[field - BIT_TEMPS_BEGIN];
  }

  inline int64 ref(MetahandleField field) const {
    return int64_fields[field - INT64_FIELDS_BEGIN];
  }
  inline int64 ref(Int64Field field) const {
    return int64_fields[field - INT64_FIELDS_BEGIN];
  }
  inline const Id& ref(IdField field) const {
    return id_fields[field - ID_FIELDS_BEGIN];
  }
  inline int64 ref(BaseVersion field) const {
    return int64_fields[field - INT64_FIELDS_BEGIN];
  }
  inline bool ref(IndexedBitField field) const {
    return bit_fields[field - BIT_FIELDS_BEGIN];
  }
  inline bool ref(IsDelField field) const {
    return bit_fields[field - BIT_FIELDS_BEGIN];
  }
  inline bool ref(BitField field) const {
    return bit_fields[field - BIT_FIELDS_BEGIN];
  }
  inline PathString ref(StringField field) const {
    return string_fields[field - STRING_FIELDS_BEGIN];
  }
  inline Blob ref(BlobField field) const {
    return blob_fields[field - BLOB_FIELDS_BEGIN];
  }
  inline bool ref(BitTemp field) const {
    return bit_temps[field - BIT_TEMPS_BEGIN];
  }
};

// A read-only meta entry.
class Entry {
  friend class Directory;
  friend std::ostream& ::operator << (std::ostream& s, const Entry& e);

 public:
  // After constructing, you must check good() to test whether the Get
  // succeeded.
  Entry(BaseTransaction* trans, GetByHandle, int64 handle);
  Entry(BaseTransaction* trans, GetById, const Id& id);
  Entry(BaseTransaction* trans, GetByTag, const PathString& tag);
  Entry(BaseTransaction* trans, GetByPath, const PathString& path);
  Entry(BaseTransaction* trans, GetByParentIdAndName, const Id& id,
      const PathString& name);
  Entry(BaseTransaction* trans, GetByParentIdAndDBName, const Id& id,
      const PathString& name);

  bool good() const { return 0 != kernel_; }

  BaseTransaction* trans() const { return basetrans_; }

  // Field accessors.
  inline int64 Get(MetahandleField field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  inline Id Get(IdField field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  inline int64 Get(Int64Field field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  inline int64 Get(BaseVersion field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  inline bool Get(IndexedBitField field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  inline bool Get(IsDelField field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  inline bool Get(BitField field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  PathString Get(StringField field) const;
  inline Blob Get(BlobField field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  inline bool Get(BitTemp field) const {
    DCHECK(kernel_);
    return kernel_->ref(field);
  }
  inline Name GetName() const {
    DCHECK(kernel_);
    return Name::FromEntryKernel(kernel_);
  }
  inline SyncName GetServerName() const {
    DCHECK(kernel_);
    return SyncName(kernel_->ref(SERVER_NAME),
                    kernel_->ref(SERVER_NON_UNIQUE_NAME));
  }
  inline bool SyncNameMatchesServerName() const {
    DCHECK(kernel_);
    SyncName sync_name(GetName());
    return sync_name == GetServerName();
  }
  inline PathString GetSyncNameValue() const {
    DCHECK(kernel_);
    // This should always be equal to GetName().sync_name().value(), but may be
    // faster.
    return kernel_->ref(UNSANITIZED_NAME).empty() ? kernel_->ref(NAME) :
        kernel_->ref(UNSANITIZED_NAME);
  }
  inline bool ExistsOnClientBecauseDatabaseNameIsNonEmpty() const {
    DCHECK(kernel_);
    return !kernel_->ref(NAME).empty();
  }
  inline bool IsRoot() const {
    DCHECK(kernel_);
    return kernel_->ref(ID).IsRoot();
  }

  void GetAllExtendedAttributes(BaseTransaction* trans,
                                std::set<ExtendedAttribute>* result);
  void GetExtendedAttributesList(BaseTransaction* trans,
                                 AttributeKeySet* result);
  // Flags all extended attributes for deletion on the next SaveChanges.
  void DeleteAllExtendedAttributes(WriteTransaction *trans);

  Directory* dir() const;

  const EntryKernel GetKernelCopy() const {
    return *kernel_;
  }


 protected:  // Don't allow creation on heap, except by sync API wrappers.
  friend class sync_api::ReadNode;
  void* operator new(size_t size) { return (::operator new)(size); }

  inline Entry(BaseTransaction* trans) : basetrans_(trans) { }

 protected:

  BaseTransaction* const basetrans_;

  EntryKernel* kernel_;

  DISALLOW_COPY_AND_ASSIGN(Entry);
};

// A mutable meta entry.  Changes get committed to the database when the
// WriteTransaction is destroyed.
class MutableEntry : public Entry {
  friend class WriteTransaction;
  friend class Directory;
  void Init(WriteTransaction* trans, const Id& parent_id,
      const PathString& name);
 public:
  MutableEntry(WriteTransaction* trans, Create, const Id& parent_id,
               const PathString& name);
  MutableEntry(WriteTransaction* trans, CreateNewUpdateItem, const Id& id);
  MutableEntry(WriteTransaction* trans, GetByHandle, int64);
  MutableEntry(WriteTransaction* trans, GetById, const Id&);
  MutableEntry(WriteTransaction* trans, GetByPath, const PathString& path);
  MutableEntry(WriteTransaction* trans, GetByParentIdAndName, const Id&,
    const PathString& name);
  MutableEntry(WriteTransaction* trans, GetByParentIdAndDBName,
    const Id& parentid, const PathString& name);

  WriteTransaction* trans() const;

  // Field Accessors.  Some of them trigger the re-indexing of the entry.
  // Return true on success, return false on failure, which means
  // that putting the value would have caused a duplicate in the index.
  bool Put(Int64Field field, const int64& value);
  bool Put(IdField field, const Id& value);
  bool Put(StringField field, const PathString& value);
  bool Put(BaseVersion field, int64 value);
  inline bool PutName(const Name& name) {
    return (Put(NAME, name.db_value()) &&
            Put(UNSANITIZED_NAME, name.GetUnsanitizedName()) &&
            Put(NON_UNIQUE_NAME, name.non_unique_value()));
  }
  inline bool PutServerName(const SyncName& server_name) {
    return (Put(SERVER_NAME, server_name.value()) &&
            Put(SERVER_NON_UNIQUE_NAME, server_name.non_unique_value()));
  }
  inline bool Put(BlobField field, const Blob& value) {
    return PutField(field, value);
  }
  inline bool Put(BitField field, bool value) {
    return PutField(field, value);
  }
  inline bool Put(IsDelField field, bool value) {
    return PutIsDel(value);
  }
  bool Put(IndexedBitField field, bool value);

  // Avoids temporary collision in index when renaming a bookmark into another
  // folder.
  bool PutParentIdAndName(const Id& parent_id, const Name& name);

  // Sets the position of this item, and updates the entry kernels of the
  // adjacent siblings so that list invariants are maintained.  Returns false
  // and fails if |predecessor_id| does not identify a sibling.  Pass the root
  // ID to put the node in first position.
  bool PutPredecessor(const Id& predecessor_id);

  inline bool Put(BitTemp field, bool value) {
    return PutTemp(field, value);
  }

 protected:

  template <typename FieldType, typename ValueType>
  inline bool PutField(FieldType field, const ValueType& value) {
    DCHECK(kernel_);
    if (kernel_->ref(field) != value) {
      kernel_->ref(field) = value;
      kernel_->dirty[static_cast<int>(field)] = true;
    }
    return true;
  }

  template <typename TempType, typename ValueType>
  inline bool PutTemp(TempType field, const ValueType& value) {
    DCHECK(kernel_);
    kernel_->ref(field) = value;
    return true;
  }

  bool PutIsDel(bool value);

 private:  // Don't allow creation on heap, except by sync API wrappers.
  friend class sync_api::WriteNode;
  void* operator new(size_t size) { return (::operator new)(size); }

  bool PutImpl(StringField field, const PathString& value);

  // Adjusts the successor and predecessor entries so that they no longer
  // refer to this entry.
  void UnlinkFromOrder();

 protected:
  MutableEntry();

  DISALLOW_COPY_AND_ASSIGN(MutableEntry);
};

template <Int64Field field_index>
class SameField;
template <Int64Field field_index>
class HashField;
class LessParentIdAndNames;
class LessMultiIncusionTargetAndMetahandle;
template <typename FieldType, FieldType field_index>
class LessField;
class LessEntryMetaHandles {
 public:
  inline bool operator()(const syncable::EntryKernel& a,
                         const syncable::EntryKernel& b) const {
    return a.ref(META_HANDLE) < b.ref(META_HANDLE);
  }
};
typedef std::set<EntryKernel, LessEntryMetaHandles> OriginalEntries;

// a WriteTransaction has a writer tag describing which body of code is doing
// the write. This is defined up here since DirectoryChangeEvent also contains
// one.
enum WriterTag {
  INVALID, SYNCER, AUTHWATCHER, UNITTEST, VACUUM_AFTER_SAVE, SYNCAPI
};

// A separate Event type and channel for very frequent changes, caused
// by anything, not just the user.
struct DirectoryChangeEvent {
  enum {
    // Means listener should go through list of original entries and
    // calculate what it needs to notify.  It should *not* call any
    // callbacks or attempt to lock anything because a
    // WriteTransaction is being held until the listener returns.
    CALCULATE_CHANGES,
    // Means the WriteTransaction has been released and the listener
    // can now take action on the changes it calculated.
    TRANSACTION_COMPLETE,
    // Channel is closing.
    SHUTDOWN
  } todo;
  // These members are only valid for CALCULATE_CHANGES.
  const OriginalEntries* originals;
  BaseTransaction* trans;
  WriterTag writer;
  typedef DirectoryChangeEvent EventType;
  static inline bool IsChannelShutdownEvent(const EventType& e) {
    return SHUTDOWN == e.todo;
  }
};

struct ExtendedAttributeKey {
  int64 metahandle;
  PathString key;
  inline bool operator < (const ExtendedAttributeKey& x) const {
    if (metahandle != x.metahandle)
      return metahandle < x.metahandle;
    return key.compare(x.key) < 0;
  }
  ExtendedAttributeKey(int64 metahandle, PathString key) :
      metahandle(metahandle), key(key) {  }
};

struct ExtendedAttributeValue {
  Blob value;
  bool is_deleted;
  bool dirty;
};

typedef std::map<ExtendedAttributeKey, ExtendedAttributeValue>
    ExtendedAttributes;

// Used to maintain our per-thread transaction state and to enforce
// our transaction invariants (e.g. no recursive transactions).
// Each time a thread enters a transaction by constructing a Read or a
// WriteTransaction object, a ThreadNode object is pulled from thread
// local storage, or created and stored in thread-local storage if it
// doesn't yet exist.
struct ThreadNode {
  const char* file;
  int line;
  base::TimeTicks wait_started;
  ThreadId id;
  ThreadNode* next;
  ThreadNode* prev;

  // True when this node is in a linked list.  Only accessed from owner thread
  // so no locking necessary.
  bool in_list;
  WriteTransaction* current_write_trans;
  PThreadCondVar condvar;  // Mutex is the kernel's transaction mutex.
  bool wake_up;  // flag for condvar.
  int tclass;  // Really a BaseTransaction::TClass, but no forward enums.

  // Linked list operations.
  inline ThreadNode() : in_list(false), current_write_trans(NULL),
       wake_up(false) {
    next = prev = this;
  }
  inline ThreadNode* Remove() {
    in_list = false;
    prev->next = next;
    next->prev = prev;
    return next = prev = this;
  }
  inline void Insert(ThreadNode* node) {
    in_list = true;
    prev = node->prev;
    next = node;
    next->prev = prev->next = this;
  }
};

struct ThreadCounts {
  int waiting;
  int active;
  // Also keep a linked list of thread information.
  ThreadNode waiting_headtail;
  ThreadNode active_headtail;

  ThreadCounts() : waiting(0), active(0) { }

  DISALLOW_COPY_AND_ASSIGN(ThreadCounts);
};

typedef PThreadScopedLock<PThreadMutex> ScopedTransactionLock;
typedef std::set<int64> MetahandleSet;

// A list of metahandles whose metadata should not be purged.
typedef std::multiset<int64> Pegs;

// The name Directory in this case means the entire directory
// structure within a single user account.
//
// Sqlite is a little goofy, in that each thread must access a database
// via its own handle.  So, a Directory object should only be accessed
// from a single thread.  Use DirectoryManager's Open() method to
// always get a directory that has been properly initialized on the
// current thread.
//
// The db is protected against concurrent modification by a reader/
// writer lock, negotiated by the ReadTransaction and WriteTransaction
// friend classes.  The in-memory indices are protected against
// concurrent modification by the kernel lock.
//
// All methods which require the reader/writer lock to be held either
//   are protected and only called from friends in a transaction
//   or are public and take a Transaction* argument.
//
// All methods which require the kernel lock to be already held take a
// ScopeKernelLock* argument.
//
// To prevent deadlock, the reader writer transaction lock must always
// be held before acquiring the kernel lock.
class ScopedKernelLock;
class IdFilter;
class DirectoryManager;
struct PathMatcher;

class Directory {
  friend class BaseTransaction;
  friend class Entry;
  friend class ExtendedAttribute;
  friend class MutableEntry;
  friend class MutableExtendedAttribute;
  friend class ReadTransaction;
  friend class ReadTransactionWithoutDB;
  friend class ScopedKernelLock;
  friend class ScopedKernelUnlock;
  friend class WriteTransaction;
  friend class TestUnsaveableDirectory;
 public:
  // Various data that the Directory::Kernel we are backing (persisting data
  // for) needs saved across runs of the application.
  struct PersistedKernelInfo {
    int64 last_sync_timestamp;
    bool initial_sync_ended;
    std::string store_birthday;
    int64 next_id;
    PersistedKernelInfo() : last_sync_timestamp(0),
        initial_sync_ended(false),
        next_id(0) {
    }
  };

  // What the Directory needs on initialization to create itself and its Kernel.
  // Filled by DirectoryBackingStore::Load.
  struct KernelLoadInfo {
    PersistedKernelInfo kernel_info;
    std::string cache_guid;  // Created on first initialization, never changes.
    int64 max_metahandle;    // Computed (using sql MAX aggregate) on init.
    KernelLoadInfo() : max_metahandle(0) {
    }
  };

  // The dirty/clean state of kernel fields backed by the share_info table.
  // This is public so it can be used in SaveChangesSnapshot for persistence.
  enum KernelShareInfoStatus {
    KERNEL_SHARE_INFO_INVALID,
    KERNEL_SHARE_INFO_VALID,
    KERNEL_SHARE_INFO_DIRTY
  };

  // When the Directory is told to SaveChanges, a SaveChangesSnapshot is
  // constructed and forms a consistent snapshot of what needs to be sent to
  // the backing store.
  struct SaveChangesSnapshot {
    KernelShareInfoStatus kernel_info_status;
    PersistedKernelInfo kernel_info;
    OriginalEntries dirty_metas;
    ExtendedAttributes dirty_xattrs;
    SaveChangesSnapshot() : kernel_info_status(KERNEL_SHARE_INFO_INVALID) {
    }
  };

  Directory();
  virtual ~Directory();

  DirOpenResult Open(const PathString& file_path, const PathString& name);

  void Close();

  int64 NextMetahandle();
  // Always returns a negative id.  Positive client ids are generated
  // by the server only.
  Id NextId();

  PathString file_path() const { return kernel_->db_path; }
  bool good() const { return NULL != store_; }

  // The sync timestamp is an index into the list of changes for an account.
  // It doesn't actually map to any time scale, it's name is an historical
  // anomaly.
  int64 last_sync_timestamp() const;
  void set_last_sync_timestamp(int64 timestamp);

  bool initial_sync_ended() const;
  void set_initial_sync_ended(bool value);

  PathString name() const { return kernel_->name_; }

  // (Account) Store birthday is opaque to the client,
  // so we keep it in the format it is in the proto buffer
  // in case we switch to a binary birthday later.
  std::string store_birthday() const;
  void set_store_birthday(std::string store_birthday);

  // Unique to each account / client pair.
  std::string cache_guid() const;

 protected:  // for friends, mainly used by Entry constructors
  EntryKernel* GetChildWithName(const Id& parent_id, const PathString& name);
  EntryKernel* GetChildWithDBName(const Id& parent_id, const PathString& name);
  EntryKernel* GetEntryByHandle(const int64 handle);
  EntryKernel* GetEntryByHandle(const int64 metahandle, ScopedKernelLock* lock);
  EntryKernel* GetEntryById(const Id& id);
  EntryKernel* GetEntryByTag(const PathString& tag);
  EntryKernel* GetRootEntry();
  EntryKernel* GetEntryByPath(const PathString& path);
  bool ReindexId(EntryKernel* const entry, const Id& new_id);
  bool ReindexParentIdAndName(EntryKernel* const entry, const Id& new_parent_id,
                              const PathString& new_name);
  // These don't do the semantic checking that the redirector needs.
  // The semantic checking is implemented higher up.
  bool Undelete(EntryKernel* const entry);
  bool Delete(EntryKernel* const entry);

  // Overridden by tests.
  virtual DirectoryBackingStore* CreateBackingStore(
      const PathString& dir_name,
      const PathString& backing_filepath);

 private:
  // These private versions expect the kernel lock to already be held
  // before calling.
  EntryKernel* GetEntryById(const Id& id, ScopedKernelLock* const lock);
  EntryKernel* GetChildWithName(const Id& parent_id,
                                const PathString& name,
                                ScopedKernelLock* const lock);
  EntryKernel* GetChildWithNameImpl(const Id& parent_id,
                                    const PathString& name,
                                    ScopedKernelLock* const lock);

  DirOpenResult OpenImpl(const PathString& file_path, const PathString& name);

  struct DirectoryEventTraits {
    typedef DirectoryEvent EventType;
    static inline bool IsChannelShutdownEvent(const DirectoryEvent& event) {
      return DIRECTORY_DESTROYED == event;
    }
  };
 public:
  typedef EventChannel<DirectoryEventTraits, PThreadMutex> Channel;
  typedef EventChannel<DirectoryChangeEvent, PThreadMutex> ChangesChannel;
  typedef std::vector<int64> ChildHandles;

  // Returns the child meta handles for given parent id.
  void GetChildHandles(BaseTransaction*, const Id& parent_id,
      const PathString& path_spec, ChildHandles* result);
  void GetChildHandles(BaseTransaction*, const Id& parent_id,
      ChildHandles* result);
  void GetChildHandlesImpl(BaseTransaction* trans, const Id& parent_id,
                           PathMatcher* matcher, ChildHandles* result);

  // Find the first or last child in the positional ordering under a parent,
  // and return its id.  Returns a root Id if parent has no children.
  Id GetFirstChildId(BaseTransaction* trans, const Id& parent_id);
  Id GetLastChildId(BaseTransaction* trans, const Id& parent_id);

  // SaveChanges works by taking a consistent snapshot of the current Directory
  // state and indices (by deep copy) under a ReadTransaction, passing this
  // snapshot to the backing store under no transaction, and finally cleaning
  // up by either purging entries no longer needed (this part done under a
  // WriteTransaction) or rolling back dirty and IS_NEW bits.  It also uses
  // internal locking to enforce SaveChanges operations are mutually exclusive.
  //
  // WARNING: THIS METHOD PERFORMS SYNCHRONOUS I/O VIA SQLITE.
  bool SaveChanges();

  // Returns the number of entities with the unsynced bit set.
  int64 unsynced_entity_count() const;

  // Get GetUnsyncedMetaHandles should only be called after SaveChanges and
  // before any new entries have been created. The intention is that the
  // syncer should call it from its PerformSyncQueries member.
  typedef std::vector<int64> UnsyncedMetaHandles;
  void GetUnsyncedMetaHandles(BaseTransaction* trans,
                              UnsyncedMetaHandles* result);

  // Get all the metahandles for unapplied updates
  typedef std::vector<int64> UnappliedUpdateMetaHandles;
  void GetUnappliedUpdateMetaHandles(BaseTransaction* trans,
                                     UnappliedUpdateMetaHandles* result);

  void GetAllExtendedAttributes(BaseTransaction* trans, int64 metahandle,
                                std::set<ExtendedAttribute>* result);
  // Get all extended attribute keys associated with a metahandle
  void GetExtendedAttributesList(BaseTransaction* trans, int64 metahandle,
                                 AttributeKeySet* result);
  // Flags all extended attributes for deletion on the next SaveChanges.
  void DeleteAllExtendedAttributes(WriteTransaction* trans, int64 metahandle);

  // Get the channel for post save notification, used by the syncer.
  inline Channel* channel() const {
    return kernel_->channel;
  }
  inline ChangesChannel* changes_channel() const {
    return kernel_->changes_channel;
  }

  // Checks tree metadata consistency.
  // If full_scan is false, the function will avoid pulling any entries from the
  // db and scan entries currently in ram.
  // If full_scan is true, all entries will be pulled from the database.
  // No return value, CHECKs will be triggered if we're given bad
  // information.
  void CheckTreeInvariants(syncable::BaseTransaction* trans,
                           bool full_scan);

  void CheckTreeInvariants(syncable::BaseTransaction* trans,
                           const OriginalEntries* originals);

  void CheckTreeInvariants(syncable::BaseTransaction* trans,
                           const MetahandleSet& handles,
                           const IdFilter& idfilter);

 private:
  // Helper to prime ids_index, parent_id_and_names_index, unsynced_metahandles
  // and unapplied_metahandles from metahandles_index.
  void InitializeIndices();

  // Constructs a consistent snapshot of the current Directory state and
  // indices (by deep copy) under a ReadTransaction for use in |snapshot|.
  // See SaveChanges() for more information.
  void TakeSnapshotForSaveChanges(SaveChangesSnapshot* snapshot);

  // Purges from memory any unused, safe to remove entries that were
  // successfully deleted on disk as a result of the SaveChanges that processed
  // |snapshot|.  See SaveChanges() for more information.
  void VacuumAfterSaveChanges(const SaveChangesSnapshot& snapshot);

  // Rolls back dirty and IS_NEW bits in the event that the SaveChanges that
  // processed |snapshot| failed, for ex. due to no disk space.
  void HandleSaveChangesFailure(const SaveChangesSnapshot& snapshot);

  void InsertEntry(EntryKernel* entry, ScopedKernelLock* lock);
  void InsertEntry(EntryKernel* entry);

  // Used by CheckTreeInvariants
  void GetAllMetaHandles(BaseTransaction* trans, MetahandleSet* result);

  static bool SafeToPurgeFromMemory(const EntryKernel* const entry);

  // Helper method used to implement GetFirstChildId/GetLastChildId.
  Id GetChildWithNullIdField(IdField field,
                             BaseTransaction* trans,
                             const Id& parent_id);

  Directory& operator = (const Directory&);

  // TODO(sync):  If lookups and inserts in these sets become
  // the bottle-neck, then we can use hash-sets instead.  But
  // that will require using #ifdefs and compiler-specific code,
  // so use standard sets for now.
 public:
  typedef std::set<EntryKernel*, LessField<MetahandleField, META_HANDLE> >
    MetahandlesIndex;
  typedef std::set<EntryKernel*, LessField<IdField, ID> > IdsIndex;
  // All entries in memory must be in both the MetahandlesIndex and
  // the IdsIndex, but only non-deleted entries will be the
  // ParentIdAndNamesIndex, because there can be multiple deleted
  // entries with the same parent id and name.
  typedef std::set<EntryKernel*, LessParentIdAndNames> ParentIdAndNamesIndex;
  typedef std::vector<int64> MetahandlesToPurge;

 private:

  struct Kernel {
    Kernel(const PathString& db_path, const PathString& name,
           const KernelLoadInfo& info);

    ~Kernel();

    PathString const db_path;
    // TODO(timsteele): audit use of the member and remove if possible
    volatile base::subtle::AtomicWord refcount;
    void AddRef();  // For convenience.
    void Release();

    // Next 3 members implement the reader/writer lock.
    PThreadMutex transaction_mutex;  // Protects next member.
    ThreadCounts thread_counts;
    pthread_key_t thread_node_key;

    // The name of this directory, used as a key into open_files_;
    PathString const name_;

    // Protects all members below.
    // The mutex effectively protects all the indices, but not the
    // entries themselves.  So once a pointer to an entry is pulled
    // from the index, the mutex can be unlocked and entry read or written.
    //
    // Never hold the mutex and do anything with the database or any
    // other buffered IO.  Violating this rule will result in deadlock.
    pthread_mutex_t mutex;
    MetahandlesIndex* metahandles_index;  // Entries indexed by metahandle
    IdsIndex* ids_index;  // Entries indexed by id
    ParentIdAndNamesIndex* parent_id_and_names_index;
    // So we don't have to create an EntryKernel every time we want to
    // look something up in an index.  Needle in haystack metaphore.
    EntryKernel needle;
    ExtendedAttributes* const extended_attributes;

    // 2 in-memory indices on bits used extremely frequently by the syncer.
    MetahandleSet* const unapplied_update_metahandles;
    MetahandleSet* const unsynced_metahandles;
    // TODO(timsteele): Add a dirty_metahandles index as we now may want to
    // optimize the SaveChanges work of scanning all entries to find dirty ones
    // due to the entire entry domain now being in-memory.

    // TODO(ncarter): Figure out what the hell this is, and comment it.
    Channel* const channel;

    // The changes channel mutex is explicit because it must be locked
    // while holding the transaction mutex and released after
    // releasing the transaction mutex.
    ChangesChannel* const changes_channel;
    PThreadMutex changes_channel_mutex;
    KernelShareInfoStatus info_status_;
    // These 5 members are backed in the share_info table, and
    // their state is marked by the flag above.
    // Last sync timestamp fetched from the server.
    int64 last_sync_timestamp_;
    // true iff we ever reached the end of the changelog.
    bool initial_sync_ended_;
    // The store birthday we were given by the server. Contents are opaque to
    // the client.
    std::string store_birthday_;
    // A unique identifier for this account's cache db, used to generate
    // unique server IDs. No need to lock, only written at init time.
    std::string cache_guid_;

    // It doesn't make sense for two threads to run SaveChanges at the same
    // time; this mutex protects that activity.
    PThreadMutex save_changes_mutex;

    // The next metahandle and id are protected by kernel mutex.
    int64 next_metahandle;
    int64 next_id;

    // Keep a history of recently flushed metahandles for debugging
    // purposes.  Protected by the save_changes_mutex.
    DebugQueue<int64, 1000> flushed_metahandles_;
  };

  Kernel* kernel_;

  DirectoryBackingStore* store_;
};

class ScopedKernelLock {
 public:
  explicit ScopedKernelLock(const Directory*);
  ~ScopedKernelLock();

  Directory* const dir_;
  DISALLOW_COPY_AND_ASSIGN(ScopedKernelLock);
};

class ScopedKernelUnlock {
 public:
  explicit ScopedKernelUnlock(ScopedKernelLock* lock);
  ~ScopedKernelUnlock();
  ScopedKernelLock* const lock_;
  DISALLOW_COPY_AND_ASSIGN(ScopedKernelUnlock);
};

// Transactions are now processed FIFO (+overlapping reads).
class BaseTransaction {
  friend class Entry;
 public:
  enum TransactionClass { READ, WRITE };

 protected:
  BaseTransaction(Directory* directory, const char* name,
                  const char* source_file, int line);

  // The members below are optionally called by descendants.
  void Lock(ThreadCounts* const thread_counts, ThreadNode* thread_node,
            TransactionClass tclass);
  void AfterLock(ThreadNode* thread_node);
  void UnlockAndLog(ThreadCounts* const thread_counts, OriginalEntries*);
  void Init(ThreadCounts* const thread_counts, TransactionClass tclass);
  ThreadNode* MakeThreadNode();

 public:
  inline Directory* directory() const { return directory_; }
  inline Id root_id() const { return Id(); }

 protected:
  Directory* const directory_;
  Directory::Kernel* const dirkernel_;  // for brevity
  const char* const name_;
  base::TimeTicks time_acquired_;
  const char* const source_file_;
  const int line_;
  WriterTag writer_;

  DISALLOW_COPY_AND_ASSIGN(BaseTransaction);
};

// Locks db in constructor, unlocks in destructor.
class ReadTransaction : public BaseTransaction {
 public:
  ReadTransaction(Directory* directory, const char* source_file,
                  int line);
  ReadTransaction(const ScopedDirLookup& scoped_dir,
                  const char* source_file, int line);

  ~ReadTransaction();

 protected:  // Don't allow creation on heap, except by sync API wrapper.
  friend class sync_api::ReadTransaction;
  void* operator new(size_t size) { return (::operator new)(size); }

  DISALLOW_COPY_AND_ASSIGN(ReadTransaction);
};

// Locks db in constructor, unlocks in destructor.
class WriteTransaction : public BaseTransaction {
  friend class MutableEntry;
 public:
  explicit WriteTransaction(Directory* directory, WriterTag writer,
                            const char* source_file, int line);
  explicit WriteTransaction(const ScopedDirLookup& directory,
                            WriterTag writer, const char* source_file,
                            int line);
  virtual ~WriteTransaction();

  void SaveOriginal(EntryKernel* entry);

 protected:
  // If I had had the foresight to create a BaseWriteTransactionClass,
  // I would not have needed this pass-through constructor and the
  // skip_destructor flag.
  explicit WriteTransaction(Directory* directory,
                            const char* name, WriterTag writer,
                            const char* source_file,
                            int line, bool skip_destructor,
                            OriginalEntries* originals);

  const bool skip_destructor_;

  // Before an entry gets modified, we copy the original into a list
  // so that we can issue change notifications when the transaction
  // is done.
  OriginalEntries* const originals_;

  DISALLOW_COPY_AND_ASSIGN(WriteTransaction);
};

bool IsLegalNewParent(BaseTransaction* trans, const Id& id, const Id& parentid);
int ComparePathNames(const PathString& a, const PathString& b);

// Exposed in header as this is used as a sqlite3 callback.
int ComparePathNames16(void*, int a_bytes, const void* a, int b_bytes,
                       const void* b);

int64 Now();

// Does wildcard processing.
BOOL PathNameMatch(const PathString& pathname, const PathString& pathspec);

PathString GetFullPath(BaseTransaction* trans, const Entry& e);

inline void ReverseAppend(const PathString& s, PathString* target) {
  target->append(s.rbegin(), s.rend());
}

class ExtendedAttribute {
 public:
  ExtendedAttribute(BaseTransaction* trans, GetByHandle,
                    const ExtendedAttributeKey& key);
  int64 metahandle() const { return i_->first.metahandle; }
  const PathString& key() const { return i_->first.key; }
  const Blob& value() const { return i_->second.value; }
  bool is_deleted() const { return i_->second.is_deleted; }
  bool good() const { return good_; }
  bool operator < (const ExtendedAttribute& x) const {
    return i_->first < x.i_->first;
  }
 protected:
  bool Init(BaseTransaction* trans,
            Directory::Kernel* const kernel,
            ScopedKernelLock* lock,
            const ExtendedAttributeKey& key);
  ExtendedAttribute() { }
  ExtendedAttributes::iterator i_;
  bool good_;
};

class MutableExtendedAttribute : public ExtendedAttribute {
 public:
  MutableExtendedAttribute(WriteTransaction* trans, GetByHandle,
                           const ExtendedAttributeKey& key);
  MutableExtendedAttribute(WriteTransaction* trans, Create,
                           const ExtendedAttributeKey& key);

  Blob* mutable_value() {
    i_->second.dirty = true;
    i_->second.is_deleted = false;
    return &(i_->second.value);
  }

  void delete_attribute() {
    i_->second.dirty = true;
    i_->second.is_deleted = true;
  }
};

// Get an extended attribute from an Entry by name. Returns a pointer
// to a const Blob containing the attribute data, or NULL if there is
// no attribute with the given name. The pointer is valid for the
// duration of the Entry's transaction.
const Blob* GetExtendedAttributeValue(const Entry& e,
                                      const PathString& attribute_name);

// This function sets only the flags needed to get this entry to sync.
void MarkForSyncing(syncable::MutableEntry* e);

// This is not a reset.  It just sets the numeric fields which are not
// initialized by the constructor to zero.
void ZeroFields(EntryKernel* entry, int first_field);

}  // namespace syncable

std::ostream& operator <<(std::ostream&, const syncable::Blob&);

browser_sync::FastDump& operator <<
  (browser_sync::FastDump&, const syncable::Blob&);

std::ostream& operator <<(std::ostream&, const syncable::ThreadNode&);

#endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_