Implement a bag of chips for sync.

sync/engine/syncer_proto_util.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/engine/syncer_proto_util.h"
 
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/engine/syncer.h"
@@ skipping 145 matching lines @@
 }
 
 // static
 void SyncerProtoUtil::AddRequestBirthday(syncable::Directory* dir,
                                          ClientToServerMessage* msg) {
   if (!dir->store_birthday().empty())
     msg->set_store_birthday(dir->store_birthday());
 }
 
 // static
+void SyncerProtoUtil::AddBagOfChips(syncable::Directory* dir,
+                                    ClientToServerMessage* msg) {
+  msg->mutable_bag_of_chips()->ParseFromString(dir->bag_of_chips());
+}
+
+// static
 void SyncerProtoUtil::SetProtocolVersion(ClientToServerMessage* msg) {
   const int current_version =
       ClientToServerMessage::default_instance().protocol_version();
   msg->set_protocol_version(current_version);
 }
 
 // static
 bool SyncerProtoUtil::PostAndProcessHeaders(ServerConnectionManager* scm,
                                             sessions::SyncSession* session,
                                             const ClientToServerMessage& msg,
@@ skipping 166 matching lines @@
 SyncerError SyncerProtoUtil::PostClientToServerMessage(
     const ClientToServerMessage& msg,
     ClientToServerResponse* response,
     SyncSession* session) {
 
   CHECK(response);
   DCHECK(!msg.get_updates().has_from_timestamp());  // Deprecated.
   DCHECK(!msg.get_updates().has_requested_types());  // Deprecated.
   DCHECK(msg.has_store_birthday() || IsVeryFirstGetUpdates(msg))
       << "Must call AddRequestBirthday to set birthday.";
+  DCHECK(msg.has_bag_of_chips())
+      << "Must call AddBagOfChips to set bag_of_chips.";
 
   syncable::Directory* dir = session->context()->directory();
 
   LogClientToServerMessage(msg);
   session->context()->traffic_recorder()->RecordClientToServerMessage(msg);
   if (!PostAndProcessHeaders(session->context()->connection_manager(), session,
                              msg, response)) {
     // There was an error establishing communication with the server.
     // We can not proceed beyond this point.
     const HttpResponse::ServerConnectionCode server_status =
         session->context()->connection_manager()->server_status();
 
     DCHECK_NE(server_status, HttpResponse::NONE);
     DCHECK_NE(server_status, HttpResponse::SERVER_CONNECTION_OK);
 
     return ServerConnectionErrorAsSyncerError(server_status);
   }
 
   LogClientToServerResponse(*response);
   session->context()->traffic_recorder()->RecordClientToServerResponse(
       *response);
 
+  // Persist a bag of chips if it has been sent by the server.
+  PersistBagOfChips(dir, *response);
+
   SyncProtocolError sync_protocol_error;
 
   // Birthday mismatch overrides any error that is sent by the server.
   if (!VerifyResponseBirthday(dir, response)) {
     sync_protocol_error.error_type = NOT_MY_BIRTHDAY;
      sync_protocol_error.action =
          DISABLE_SYNC_ON_CLIENT;
   } else if (response->has_error()) {
     // This is a new server. Just get the error from the protocol.
     sync_protocol_error = ConvertErrorPBToLocalType(response->error());
@@ skipping 118 matching lines @@
 }
 
 // static
 const std::string& SyncerProtoUtil::NameFromCommitEntryResponse(
     const sync_pb::CommitResponse_EntryResponse& entry) {
   if (entry.has_non_unique_name())
     return entry.non_unique_name();
   return entry.name();
 }
 
+// static
+void SyncerProtoUtil::PersistBagOfChips(syncable::Directory* dir,
+    const sync_pb::ClientToServerResponse& response) {
+  if (!response.has_new_bag_of_chips())
+    return;
+  std::string bag_of_chips;
+  if (response.new_bag_of_chips().SerializeToString(&bag_of_chips))
+    dir->set_bag_of_chips(bag_of_chips);
+}
+
 std::string SyncerProtoUtil::SyncEntityDebugString(
     const sync_pb::SyncEntity& entry) {
   const std::string& mtime_str =
       GetTimeDebugString(ProtoTimeToTime(entry.mtime()));
   const std::string& ctime_str =
       GetTimeDebugString(ProtoTimeToTime(entry.ctime()));
   return base::StringPrintf(
       "id: %s, parent_id: %s, "
       "version: %"PRId64"d, "
       "mtime: %" PRId64"d (%s), "
@@ skipping 25 matching lines @@
 std::string SyncerProtoUtil::ClientToServerResponseDebugString(
     const ClientToServerResponse& response) {
   // Add more handlers as needed.
   std::string output;
   if (response.has_get_updates())
     output.append(GetUpdatesResponseString(response.get_updates()));
   return output;
 }
 
 }  // namespace syncer