sync: Report GetUpdate triggers to the server

sync/sessions/sync_session.h

 // Copyright 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.
 
 // A class representing an attempt to synchronize the local syncable data
 // store with a sync server. A SyncSession instance is passed as a stateful
 // bundle to and from various SyncerCommands with the goal of converging the
 // client view of data with that of the server. The commands twiddle with
 // session status in response to events and hiccups along the way, set and
 // query session progress with regards to conflict resolution and applying
@@ skipping 18 matching lines @@
 #include "sync/internal_api/public/sessions/sync_session_snapshot.h"
 #include "sync/sessions/ordered_commit_set.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/sessions/sync_session_context.h"
 
 namespace syncer {
 class ModelSafeWorker;
 
 namespace sessions {
 
+class NudgeTracker;
+
 class SYNC_EXPORT_PRIVATE SyncSession {
  public:
   // The Delegate services events that occur during the session requiring an
   // explicit (and session-global) action, as opposed to events that are simply
   // recorded in per-session state.
   class SYNC_EXPORT_PRIVATE Delegate {
    public:
     // The client was throttled and should cease-and-desist syncing activity
     // until the specified time.
     virtual void OnSilencedUntil(const base::TimeTicks& silenced_until) = 0;
@@ skipping 30 matching lines @@
     // stops the current sync cycle and purges the client. In the new model
     // the former would be done by the |SyncProtocolError| and
     // the latter(which is an action) would be done in ProfileSyncService
     // along with the rest of the actions.
     virtual void OnShouldStopSyncingPermanently() = 0;
 
     // Called for the syncer to respond to the error sent by the server.
     virtual void OnSyncProtocolError(
         const sessions::SyncSessionSnapshot& snapshot) = 0;
 
+    // Called when the server wants to change the number of hints the client
+    // will buffer locally.
+    virtual void OnReceivedClientInvalidationHintBufferSize(int size) = 0;

[tim (not reviewing), 2013/05/07 22:40:34]

You use int here but size_t in NudgeTracker, was there a reason? I didn't see
any input validation that probably wouldn't hurt.

[rlarocque, 2013/05/07 22:56:49]

The protobufs provide us with ints, so I've used ints in the functions that are
meant to transmit data from the protobufs to other parts of the code.  

All The SyncSession::Delegate implementations will treat this as an int, because
that's the format of the message.  

The NudgeTracker deals in size_t, because that's the type of the size of a
vector (or any in-memory list).  The value passed to
NudgeTracker::SetHintBufferSize() will only be used in comparisons against a
size_t, so we'd might as well ask for it and store it in that format.  

What sort of input checking were you looking for?  Should we make sure the int
is non-negative before passing it along to the nudge tracker?  

Should we check that it's within some reasonable bounds?  It seems like that
would defeat the point of making it server-controlled.

[tim (not reviewing), 2013/05/07 23:35:50]

Sanity checking that the value was greater than zero was what I had in mind. I
left it open in case you had any other ideas as well.

+
    protected:
     virtual ~Delegate() {}
   };
 
-  SyncSession(SyncSessionContext* context,
-              Delegate* delegate,
-              const SyncSourceInfo& source);
+  // Build a session with a nudge tracker.  Used for sync cycles with origin of
+  // GU_TRIGGER (ie. notification, local change, and/or refresh request)
+  static SyncSession* BuildForNudge(SyncSessionContext* context,
+                                    Delegate* delegate,
+                                    const SyncSourceInfo& source,
+                                    const NudgeTracker* nudge_tracker);
+
+  // Build a session without a nudge tracker.  Used for poll or configure type
+  // sync cycles.
+  static SyncSession* Build(SyncSessionContext* context,
+                            Delegate* delegate,
+                            const SyncSourceInfo& source);
+
   ~SyncSession();
 
   // Builds a thread-safe and read-only copy of the current session state.
   SyncSessionSnapshot TakeSnapshot() const;
 
   // Builds and sends a snapshot to the session context's listeners.
   void SendEventNotification(SyncEngineEvent::EventCause cause);
 
   // TODO(akalin): Split this into context() and mutable_context().
   SyncSessionContext* context() const { return context_; }
   Delegate* delegate() const { return delegate_; }
   const StatusController& status_controller() const {
     return *status_controller_.get();
   }
   StatusController* mutable_status_controller() {
     return status_controller_.get();
   }
 
   const SyncSourceInfo& source() const { return source_; }
 
+  const NudgeTracker* nudge_tracker() const { return nudge_tracker_; }
+
  private:
+  SyncSession(SyncSessionContext* context,
+              Delegate* delegate,
+              const SyncSourceInfo& source,
+              const NudgeTracker* nudge_tracker);
+
   // The context for this session, guaranteed to outlive |this|.
   SyncSessionContext* const context_;
 
   // The source for initiating this sync session.
   SyncSourceInfo source_;
 
   // The delegate for this session, must never be NULL.
   Delegate* const delegate_;
 
   // Our controller for various status and error counters.
   scoped_ptr<StatusController> status_controller_;
 
+  const NudgeTracker* nudge_tracker_;
+
   DISALLOW_COPY_AND_ASSIGN(SyncSession);
 };
 
 }  // namespace sessions
 }  // namespace syncer
 
 #endif  // SYNC_SESSIONS_SYNC_SESSION_H_