Add unique hashing to sync API.

chrome/browser/sync/engine/syncapi.h

 // 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.
 
 // This file defines the "sync API", an interface to the syncer
 // backend that exposes (1) the core functionality of maintaining a consistent
 // local snapshot of a hierarchical object set; (2) a means to transactionally
 // access and modify those objects; (3) a means to control client/server
 // synchronization tasks, namely: pushing local object modifications to a
 // server, pulling nonlocal object modifications from a server to this client,
@@ skipping 31 matching lines @@
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/scoped_ptr.h"
 #include "build/build_config.h"
 #include "chrome/browser/google_service_auth_error.h"
 #include "chrome/browser/sync/notification_method.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 #include "googleurl/src/gurl.h"
 

[ncarter (slow), 2010/02/18 01:05:40]

no blank line.

[chron, 2010/02/18 01:09:32]

Done.

+#include "testing/gtest/include/gtest/gtest_prod.h" // for FRIEND_TEST
+
 namespace browser_sync {
 class ModelSafeWorkerRegistrar;
 }
 
 // Forward declarations of internal class types so that sync API objects
 // may have opaque pointers to these types.
 namespace syncable {
 class BaseTransaction;
 class DirectoryManager;
 class Entry;
@@ skipping 45 matching lines @@
 class BaseNode {
  public:
   // All subclasses of BaseNode must provide a way to initialize themselves by
   // doing an ID lookup.  Returns false on failure.  An invalid or deleted
   // ID will result in failure.
   virtual bool InitByIdLookup(int64 id) = 0;
 
   // All subclasses of BaseNode must also provide a way to initialize themselves
   // by doing a client tag lookup. Returns false on failure. A deleted node
   // will return FALSE.
-  virtual bool InitByClientTagLookup(const std::string& tag) = 0;
+  virtual bool InitByClientTagLookup(syncable::ModelType model_type,
+      const std::string& tag) = 0;
 
   // Each object is identified by a 64-bit id (internally, the syncable
   // metahandle).  These ids are strictly local handles.  They will persist
   // on this client, but the same object on a different client may have a
   // different ID value.
   int64 GetId() const;
 
   // Nodes are hierarchically arranged into a single-rooted tree.
   // InitByRootLookup on ReadNode allows access to the root. GetParentId is
   // how you find a node's parent.
@@ skipping 49 matching lines @@
   // children, return 0.
   int64 GetFirstChildId() const;
 
   // These virtual accessors provide access to data members of derived classes.
   virtual const syncable::Entry* GetEntry() const = 0;
   virtual const BaseTransaction* GetTransaction() const = 0;
 
  protected:
   BaseNode();
   virtual ~BaseNode();
+  // The server has a size limit on client tags, so we generate a fixed length
+  // hash locally. This also ensures that ModelTypes have unique namespaces.
+  static std::string GenerateSyncableHash(syncable::ModelType model_type,
+      const std::string& client_tag);
 
  private:
   // Node is meant for stack use only.
   void* operator new(size_t size);
 
+  friend class SyncApiTest;
+  FRIEND_TEST(SyncApiTest, GenerateSyncableHash);
+
   DISALLOW_COPY_AND_ASSIGN(BaseNode);
 };
 
 // WriteNode extends BaseNode to add mutation, and wraps
 // syncable::MutableEntry. A WriteTransaction is needed to create a WriteNode.
 class WriteNode : public BaseNode {
  public:
   // Create a WriteNode using the given transaction.
   explicit WriteNode(WriteTransaction* transaction);
   virtual ~WriteNode();
 
   // A client must use one (and only one) of the following Init variants to
   // populate the node.
 
   // BaseNode implementation.
   virtual bool InitByIdLookup(int64 id);
-  virtual bool InitByClientTagLookup(const std::string& tag);
+  virtual bool InitByClientTagLookup(syncable::ModelType model_type,
+      const std::string& tag);
 
   // Create a new node with the specified parent and predecessor.  |model_type|
   // dictates the type of the item, and controls which EntitySpecifics proto
   // extension can be used with this item.  Use a NULL |predecessor|
   // to indicate that this is to be the first child.
   // |predecessor| must be a child of |new_parent| or NULL. Returns false on
   // failure.
   bool InitByCreation(syncable::ModelType model_type,
                       const BaseNode& parent,
                       const BaseNode* predecessor);
@@ skipping 84 matching lines @@
   // Create an unpopulated ReadNode on the given transaction.  Call some flavor
   // of Init to populate the ReadNode with a database entry.
   explicit ReadNode(const BaseTransaction* transaction);
   virtual ~ReadNode();
 
   // A client must use one (and only one) of the following Init variants to
   // populate the node.
 
   // BaseNode implementation.
   virtual bool InitByIdLookup(int64 id);
-  virtual bool InitByClientTagLookup(const std::string& tag);
+  virtual bool InitByClientTagLookup(syncable::ModelType model_type,
+      const std::string& tag);
 
   // There is always a root node, so this can't fail.  The root node is
   // never mutable, so root lookup is only possible on a ReadNode.
   void InitByRootLookup();
 
   // Each server-created permanent node is tagged with a unique string.
   // Look up the node with the particular tag.  If it does not exist,
   // return false.  Since these nodes are special, lookup is only
   // provided through ReadNode.
   // TODO(chron): Rename this function.
@@ skipping 398 matching lines @@
   // This allows actual HttpPostProvider subclass implementations to be
   // reference counted, which is useful if a particular implementation uses
   // multiple threads to serve network requests.
   virtual void Destroy(HttpPostProviderInterface* http) = 0;
   virtual ~HttpPostProviderFactory() { }
 };
 
 }  // namespace sync_api
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCAPI_H_