sync: Support non-blocking initial sync in proto

sync/engine/sync_scheduler_impl.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/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/auto_reset.h"
@@ skipping 380 matching lines @@
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
 
   SDVLOG_LOC(nudge_location, 2)
       << "Scheduling sync because we received invalidation for "
       << ModelTypeToString(model_type);
   nudge_tracker_.RecordRemoteInvalidation(model_type, invalidation.Pass());
   ScheduleNudgeImpl(desired_delay, nudge_location);
 }
 
+void SyncSchedulerImpl::ScheduleInitialSyncNudge(syncer::ModelType model_type) {

[stanisc, 2014/07/17 18:46:10]

This is called ScheduleInitialSyncNudge. Does the "initial" part imply that this
should be called only once per model_type? Would calling this multiple times be
a problem?

[rlarocque, 2014/07/17 18:58:06]

It should be very uncommon that it gets called more than once per ModelType, but
not impossible.  

We should to call it every time we need to ask the server to re-sync our type
when we're starting from nothing.  This will happen when the user first signs
in.  It can also happen if we've deleted our local sync data because a user
disabled then re-enabled sync for this type.  Or it could be that the server
requested a "migration", which is to say that it asked the client to clear its
sync data and start syncing from scratch.

The effects of calling it unnecessarily won't be too severe.  It would cause the
client to perform a GetUpdate request.  The server would (1) be forced to read
from its storage, since it is not allowed to "optimize" requests that carry this
flag, and (2) log this as an initial sync request, which might have an impact on
our graphs or metrics.

We certainly don't want to call it for no reason, but it's reasonably safe in
that there would be no data corruption if we did.

+  DCHECK(CalledOnValidThread());
+
+  SDVLOG(2) << "Scheduling non-blocking initial sync for "
+            << ModelTypeToString(model_type);
+  nudge_tracker_.RecordInitialSyncRequired(model_type);
+  ScheduleNudgeImpl(TimeDelta::FromSeconds(0), FROM_HERE);
+}
+
 // TODO(zea): Consider adding separate throttling/backoff for datatype
 // refresh requests.
 void SyncSchedulerImpl::ScheduleNudgeImpl(
     const TimeDelta& delay,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
 
   if (no_scheduling_allowed_) {
     NOTREACHED() << "Illegal to schedule job while session in progress.";
     return;
@@ skipping 498 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer