Add information about sync session and other useful data to about:sync.

chrome/browser/sync/sync_ui_util.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/sync_ui_util.h"
 
 #include "base/command_line.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/time_formatting.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service.h"
+#include "chrome/browser/sync/protocol/proto_enum_conversions.h"
+#include "chrome/browser/sync/sessions/session_state.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/url_constants.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 255 matching lines @@
 
 void AddBoolSyncDetail(ListValue* details,
                        const std::string& stat_name,
                        bool stat_value) {
   DictionaryValue* val = new DictionaryValue;
   val->SetString("stat_name", stat_name);
   val->SetBoolean("stat_value", stat_value);
   details->Append(val);
 }
 
+void AddStringSyncDetails(ListValue* details, const std::string& stat_name,
+                          const std::string& stat_value) {
+  DictionaryValue* val = new DictionaryValue;
+  val->SetString("stat_name", stat_name);
+  val->SetString("stat_value", stat_value);
+  details->Append(val);
+}
+
 void AddIntSyncDetail(ListValue* details, const std::string& stat_name,
                       int64 stat_value) {
   DictionaryValue* val = new DictionaryValue;
   val->SetString("stat_name", stat_name);
   val->SetString("stat_value", base::FormatNumber(stat_value));
   details->Append(val);
 }
 
 string16 ConstructTime(int64 time_in_int) {
   base::Time time = base::Time::FromInternalValue(time_in_int);
@@ skipping 92 matching lines @@
                                    full_status.updates_received);
     sync_ui_util::AddIntSyncDetail(details,
                                    "Updates Downloaded (Tombstones)",
                                    full_status.tombstone_updates_received);
     sync_ui_util::AddBoolSyncDetail(details,
                                     "Disk Full",
                                     full_status.disk_full);
     sync_ui_util::AddIntSyncDetail(details,
                                    "Max Consecutive Errors",
                                    full_status.max_consecutive_errors);
+    sync_ui_util::AddIntSyncDetail(details,
+                                   "Empty Getupdates",
+                                   full_status.empty_getupdates);
+    sync_ui_util::AddIntSyncDetail(details,
+                                   "Nonempty Getupdates",
+                                   full_status.nonempty_getupdates);
+
+    const browser_sync::sessions::SyncSessionSnapshot* snapshot =
+        service->GetLastSessionSnapshot();
+
+    // |snapshot| could be null if sync is not yet completed.
+    if (snapshot) {
+      sync_ui_util::AddIntSyncDetail(details, "Download Count(This Session)",
+            snapshot->syncer_status.num_updates_downloaded_total);
+      sync_ui_util::AddIntSyncDetail(details, "Commit Count(This Session)",
+            snapshot->syncer_status.num_successful_commits);
+      sync_ui_util::AddStringSyncDetails(details, "Last Sync Source",
+            browser_sync::GetUpdatesSourceString(
+            snapshot->source.updates_source));
+
+      // Print the count of entries from snapshot. Warning: This might be
+      // slightly out of date if there are client side changes that are yet
+      // unsynced  However if we query the latest count here we will
+      // have to hold the transaction which means we cannot display this page
+      // when syncing.

[lipalani1, 2011/05/13 00:43:54]

ACtually holding a transaction is not necessary. May be the right thing to do is
protect the code to get the count with a lock. But I still prefer this method
otherwise we will have to plumb a method from PSS all the directory. However I
will add a lock to the count method and send another cr.

[lipalani1, 2011/05/13 01:06:43]

Done.

+      sync_ui_util::AddIntSyncDetail(details, "Entries" ,
+                                     snapshot->num_entries);
+      sync_ui_util::AddBoolSyncDetail(details, "Throttled",
+                                      snapshot->syncer_status.throttled);
+    }
 
     if (service->unrecoverable_error_detected()) {
       strings->Set("unrecoverable_error_detected", new FundamentalValue(true));
       strings->SetString("unrecoverable_error_message",
                          service->unrecoverable_error_message());
       tracked_objects::Location loc(service->unrecoverable_error_location());
       std::string location_str;
       loc.Write(true, true, &location_str);
       strings->SetString("unrecoverable_error_location", location_str);
     } else if (!service->sync_initialized()) {
@@ skipping 30 matching lines @@
 
       DictionaryValue* val = new DictionaryValue;
       val->SetString("stat_name", "Autofill Migration Time");
       val->SetString("stat_value", ConstructTime(info.autofill_migration_time));
       details->Append(val);
     }
   }
 }
 
 }  // namespace sync_ui_util