[Sync] Move sessions/ to engine/cycle/ and rename things to match.

components/sync/engine_impl/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 "components/sync/engine_impl/syncer_proto_util.h"
 
 #include <map>
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/time.h"
+#include "components/sync/engine_impl/cycle/sync_cycle.h"
 #include "components/sync/engine_impl/net/server_connection_manager.h"
 #include "components/sync/engine_impl/syncer.h"
 #include "components/sync/engine_impl/syncer_types.h"
 #include "components/sync/engine_impl/traffic_logger.h"
 #include "components/sync/protocol/sync_enums.pb.h"
 #include "components/sync/protocol/sync_protocol_error.h"
-#include "components/sync/sessions_impl/sync_session.h"
 #include "components/sync/syncable/directory.h"
 #include "components/sync/syncable/entry.h"
 #include "components/sync/syncable/syncable-inl.h"
 #include "components/sync/syncable/syncable_proto_util.h"
 #include "google_apis/google_api_keys.h"
 
 using std::string;
 using std::stringstream;
 using sync_pb::ClientToServerMessage;
 using sync_pb::ClientToServerResponse;
 
 namespace syncer {
 
-using sessions::SyncSession;
 using syncable::BASE_VERSION;
 using syncable::CTIME;
 using syncable::ID;
 using syncable::IS_DEL;
 using syncable::IS_DIR;
 using syncable::IS_UNSYNCED;
 using syncable::MTIME;
 using syncable::PARENT_ID;
 
 namespace {
@@ skipping 277 matching lines @@
 
 // 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,
+                                            SyncCycle* cycle,
                                             const ClientToServerMessage& msg,
                                             ClientToServerResponse* response) {
   ServerConnectionManager::PostBufferParams params;
   DCHECK(msg.has_protocol_version());
   DCHECK_EQ(msg.protocol_version(),
             ClientToServerMessage::default_instance().protocol_version());
   msg.SerializeToString(&params.buffer_in);
 
   // Fills in params.buffer_out and params.response.
   if (!scm->PostBufferWithCachedAuth(&params)) {
@@ skipping 15 matching lines @@
           base::TimeDelta::FromSeconds(command.throttle_delay_seconds());
     }
   }
   return throttle_delay;
 }
 
 // static
 SyncerError SyncerProtoUtil::PostClientToServerMessage(
     ClientToServerMessage* msg,
     ClientToServerResponse* response,
-    SyncSession* session,
+    SyncCycle* cycle,
     ModelTypeSet* partial_failure_data_types) {
   CHECK(response);
   DCHECK(!msg->get_updates().has_from_timestamp());   // Deprecated.
   DCHECK(!msg->get_updates().has_requested_types());  // Deprecated.
 
   // Add must-have fields.
   SetProtocolVersion(msg);
-  AddRequestBirthday(session->context()->directory(), msg);
+  AddRequestBirthday(cycle->context()->directory(), msg);
   DCHECK(msg->has_store_birthday() || !IsBirthdayRequired(*msg));
-  AddBagOfChips(session->context()->directory(), msg);
+  AddBagOfChips(cycle->context()->directory(), msg);
   msg->set_api_key(google_apis::GetAPIKey());
-  msg->mutable_client_status()->CopyFrom(session->context()->client_status());
-  msg->set_invalidator_client_id(session->context()->invalidator_client_id());
+  msg->mutable_client_status()->CopyFrom(cycle->context()->client_status());
+  msg->set_invalidator_client_id(cycle->context()->invalidator_client_id());
 
-  syncable::Directory* dir = session->context()->directory();
+  syncable::Directory* dir = cycle->context()->directory();
 
   LogClientToServerMessage(*msg);
-  if (!PostAndProcessHeaders(session->context()->connection_manager(), session,
+  if (!PostAndProcessHeaders(cycle->context()->connection_manager(), cycle,
                              *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();
+        cycle->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);
 
   // Persist a bag of chips if it has been sent by the server.
   PersistBagOfChips(dir, *response);
 
   SyncProtocolError sync_protocol_error =
       GetProtocolErrorFromResponse(*response, dir);
 
   // Inform the delegate of the error we got.
-  session->delegate()->OnSyncProtocolError(sync_protocol_error);
+  cycle->delegate()->OnSyncProtocolError(sync_protocol_error);
 
   // Update our state for any other commands we've received.
   if (response->has_client_command()) {
     const sync_pb::ClientCommand& command = response->client_command();
     if (command.has_max_commit_batch_size()) {
-      session->context()->set_max_commit_batch_size(
+      cycle->context()->set_max_commit_batch_size(
           command.max_commit_batch_size());
     }
 
     if (command.has_set_sync_long_poll_interval()) {
-      session->delegate()->OnReceivedLongPollIntervalUpdate(
+      cycle->delegate()->OnReceivedLongPollIntervalUpdate(
           base::TimeDelta::FromSeconds(command.set_sync_long_poll_interval()));
     }
 
     if (command.has_set_sync_poll_interval()) {
-      session->delegate()->OnReceivedShortPollIntervalUpdate(
+      cycle->delegate()->OnReceivedShortPollIntervalUpdate(
           base::TimeDelta::FromSeconds(command.set_sync_poll_interval()));
     }
 
     if (command.has_sessions_commit_delay_seconds()) {
       std::map<ModelType, base::TimeDelta> delay_map;
       delay_map[SESSIONS] =
           base::TimeDelta::FromSeconds(command.sessions_commit_delay_seconds());
-      session->delegate()->OnReceivedCustomNudgeDelays(delay_map);
+      cycle->delegate()->OnReceivedCustomNudgeDelays(delay_map);
     }
 
     if (command.has_client_invalidation_hint_buffer_size()) {
-      session->delegate()->OnReceivedClientInvalidationHintBufferSize(
+      cycle->delegate()->OnReceivedClientInvalidationHintBufferSize(
           command.client_invalidation_hint_buffer_size());
     }
 
     if (command.has_gu_retry_delay_seconds()) {
-      session->delegate()->OnReceivedGuRetryDelay(
+      cycle->delegate()->OnReceivedGuRetryDelay(
           base::TimeDelta::FromSeconds(command.gu_retry_delay_seconds()));
     }
 
     if (command.custom_nudge_delays_size() > 0) {
       // Note that because this happens after the sessions_commit_delay_seconds
       // handling, any SESSIONS value in this map will override the one in
       // sessions_commit_delay_seconds.
       std::map<ModelType, base::TimeDelta> delay_map;
       for (int i = 0; i < command.custom_nudge_delays_size(); ++i) {
         ModelType type = GetModelTypeFromSpecificsFieldNumber(
             command.custom_nudge_delays(i).datatype_id());
         if (ProtocolTypes().Has(type)) {
           delay_map[type] = base::TimeDelta::FromMilliseconds(
               command.custom_nudge_delays(i).delay_ms());
         }
       }
-      session->delegate()->OnReceivedCustomNudgeDelays(delay_map);
+      cycle->delegate()->OnReceivedCustomNudgeDelays(delay_map);
     }
   }
 
   // Now do any special handling for the error type and decide on the return
   // value.
   switch (sync_protocol_error.error_type) {
     case UNKNOWN_ERROR:
       LOG(WARNING) << "Sync protocol out-of-date. The server is using a more "
                    << "recent version.";
       return SERVER_RETURN_UNKNOWN_ERROR;
     case SYNC_SUCCESS:
       LogResponseProfilingData(*response);
       return SYNCER_OK;
     case THROTTLED:
       if (sync_protocol_error.error_data_types.Empty()) {
         DLOG(WARNING) << "Client fully throttled by syncer.";
-        session->delegate()->OnThrottled(GetThrottleDelay(*response));
+        cycle->delegate()->OnThrottled(GetThrottleDelay(*response));
       } else {
         DLOG(WARNING) << "Some types throttled by syncer.";
-        session->delegate()->OnTypesThrottled(
+        cycle->delegate()->OnTypesThrottled(
             sync_protocol_error.error_data_types, GetThrottleDelay(*response));
       }
       return SERVER_RETURN_THROTTLED;
     case TRANSIENT_ERROR:
       return SERVER_RETURN_TRANSIENT_ERROR;
     case MIGRATION_DONE:
       LOG_IF(ERROR, 0 >= response->migrated_data_type_id_size())
           << "MIGRATION_DONE but no types specified.";
-      session->delegate()->OnReceivedMigrationRequest(
+      cycle->delegate()->OnReceivedMigrationRequest(
           GetTypesToMigrate(*response));
       return SERVER_RETURN_MIGRATION_DONE;
     case CLEAR_PENDING:
       return SERVER_RETURN_CLEAR_PENDING;
     case NOT_MY_BIRTHDAY:
       return SERVER_RETURN_NOT_MY_BIRTHDAY;
     case DISABLED_BY_ADMIN:
       return SERVER_RETURN_DISABLED_BY_ADMIN;
     case PARTIAL_FAILURE:
       // This only happens when partial throttling during GetUpdates.
       if (!sync_protocol_error.error_data_types.Empty()) {
         DLOG(WARNING) << "Some types throttled by syncer during GetUpdates.";
-        session->delegate()->OnTypesThrottled(
+        cycle->delegate()->OnTypesThrottled(
             sync_protocol_error.error_data_types, GetThrottleDelay(*response));
       }
       if (partial_failure_data_types != NULL) {
         *partial_failure_data_types = sync_protocol_error.error_data_types;
       }
       return SERVER_RETURN_PARTIAL_FAILURE;
     case CLIENT_DATA_OBSOLETE:
       return SERVER_RETURN_CLIENT_DATA_OBSOLETE;
     default:
       NOTREACHED();
@@ skipping 85 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