sync: Improve handling of bad UniquePos (retry)

sync/internal_api/public/base/unique_position.cc

 // 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.
 
 #include "sync/internal_api/public/base/unique_position.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "sync/protocol/unique_position.pb.h"
 #include "third_party/zlib/zlib.h"
 
 namespace syncer {
 
 const size_t UniquePosition::kSuffixLength = 28;
 const size_t UniquePosition::kCompressBytesThreshold = 128;
 
 // static.
 bool UniquePosition::IsValidSuffix(const std::string& suffix) {
   // The suffix must be exactly the specified length, otherwise unique suffixes
   // are not sufficient to guarantee unique positions (because prefix + suffix
   // == p + refixsuffix).
-  return suffix.length() == kSuffixLength;
+  return suffix.length() == kSuffixLength
+      && suffix[kSuffixLength-1] != 0;
 }
 
 // static.
 bool UniquePosition::IsValidBytes(const std::string& bytes) {
   // The first condition ensures that our suffix uniqueness is sufficient to
   // guarantee position uniqueness.  Otherwise, it's possible the end of some
   // prefix + some short suffix == some long suffix.
   // The second condition ensures that FindSmallerWithSuffix can always return a
   // result.
   return bytes.length() >= kSuffixLength
       && bytes[bytes.length()-1] != 0;
 }
 
 // static.
+std::string UniquePosition::RandomSuffix() {
+  // Users random data for all but the last byte.  The last byte must not be
+  // zero.  We arbitrarily set it to 0x7f.
+  return base::RandBytesAsString(kSuffixLength - 1) + "\x7f";
+}
+
+// static.
 UniquePosition UniquePosition::CreateInvalid() {
   UniquePosition pos;
   DCHECK(!pos.IsValid());
   return pos;
 }
 
 // static.
 UniquePosition UniquePosition::FromProto(const sync_pb::UniquePosition& proto) {
   if (proto.has_custom_compressed_v1()) {
     return UniquePosition(proto.custom_compressed_v1());
@@ skipping 557 matching lines @@
         return false;
       }
     }
   }
   // We don't bother looking for the existence or checking the validity of
   // any partial blocks.  There's no way they could be invalid anyway.
   return true;
 }
 
 }  // namespace syncer