[Sync] - In about:sync page display if the first sync after restart has taken place or not.

chrome/browser/sync/internal_api/sync_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_INTERNAL_API_SYNC_MANAGER_H_
 #define CHROME_BROWSER_SYNC_INTERNAL_API_SYNC_MANAGER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 76 matching lines @@
   // Status encapsulates detailed state about the internals of the SyncManager.
   struct Status {
     // Summary is a distilled set of important information that the end-user may
     // wish to be informed about (through UI, for example). Note that if a
     // summary state requires user interaction (such as auth failures), more
     // detailed information may be contained in additional status fields.
     enum Summary {
       // The internal instance is in an unrecognizable state. This should not
       // happen.
       INVALID = 0,
+      // A sync has not happened since restart.
+      UNININITIALIZED,

[rlarocque, 2012/02/02 22:44:13]

I no longer think this is a good name.  It makes sense in this context
(especially in the constructor's member initializers) but not in about:sync.  I
worry it could be misinterpreted as meaning that the sync service is not
initialized, as opposed to indicating that the sync status has not been
initialized.  

Maybe UNKNOWN would be a better choice?

Sorry about the flip-flop.

[lipalani1, 2012/02/03 01:55:39]

our target audience is:
1. We expect only developers to see this. But the developer need not work on
chrome sync or he could just be a chrome committer.
What I have done is the status text would read READY but the description would
read there has been no sync since restart so the following values are
speculative.

With that in mind I think UNINITIALIZED looks to be a reasonably right name for
this enum.
On 2012/02/02 22:44:13, rlarocque wrote:

       // Can't connect to server, but there are no pending changes in
       // our local cache.
       OFFLINE,
       // Can't connect to server, and there are pending changes in our
       // local cache.
       OFFLINE_UNSYNCED,
       // Connected and syncing.
       SYNCING,
       // Connected, no pending changes.
       READY,
-      // Can't connect to server, and we haven't completed the initial
-      // sync yet.  So there's nothing we can do but wait for the server.
+      // Can't connect to server.
+      // So there's nothing we can do but wait for the server.
+      // This state indicates there are no pending changes. Client
+      // is trying to sync possibly because of a notification.
       OFFLINE_UNUSABLE,
 
       SUMMARY_STATUS_COUNT,
     };
 
     Status();
     ~Status();
 
     Summary summary;
     bool authenticated;      // Successfully authenticated via GAIA.
@@ skipping 11 matching lines @@
 
     browser_sync::SyncProtocolError sync_protocol_error;
 
     // Number of unsynced items counted at the start of most recent sync cycle.
     int unsynced_count;
 
     // Number of conflicting items counted during most recent sync cycle.
     int conflicting_count;
 
     bool syncing;
-    // True after a client has done a first sync.
-    bool initial_sync_ended;
 
     // Total updates available.  If zero, nothing left to download.
     int64 updates_available;
     // Total updates received by the syncer since browser start.
     int updates_received;
 
     // Of updates_received, how many were tombstones.
     int tombstone_updates_received;
 
     // Total number of overwrites due to conflict resolver since browser start.
     int num_local_overwrites_total;
     int num_server_overwrites_total;
 
     // Count of empty and non empty getupdates;
     int nonempty_get_updates;
     int empty_get_updates;
 
     // Count of useless and useful syncs we perform.
     int useless_sync_cycles;
     int useful_sync_cycles;
 
+    // Sync cycle count.
+    int sync_count;
+
     // Encryption related.
     syncable::ModelTypeSet encrypted_types;
     bool cryptographer_ready;
     bool crypto_has_pending_keys;
 
     // The unique identifer for this client.
     std::string unique_id;
   };
 
   // An interface the embedding application implements to be notified
@@ skipping 444 matching lines @@
 syncable::ModelTypeSet GetTypesWithEmptyProgressMarkerToken(
     syncable::ModelTypeSet types,
     sync_api::UserShare* share);
 
 // Returns the string representation of a PassphraseRequiredReason value.
 std::string PassphraseRequiredReasonToString(PassphraseRequiredReason reason);
 
 }  // namespace sync_api
 
 #endif  // CHROME_BROWSER_SYNC_INTERNAL_API_SYNC_MANAGER_H_