Introduce browser_sync::ExtensionsActivityMonitor to collect extensions API u...

chrome/browser/sync/engine/syncer.cc

 // Copyright (c) 2009 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 entry.
 
 #include "chrome/browser/sync/engine/syncer.h"
 
 #include "base/format_macros.h"
+#include "base/message_loop.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/sync/engine/apply_updates_command.h"
 #include "chrome/browser/sync/engine/build_and_process_conflict_sets_command.h"
 #include "chrome/browser/sync/engine/build_commit_command.h"
 #include "chrome/browser/sync/engine/conflict_resolver.h"
 #include "chrome/browser/sync/engine/download_updates_command.h"
 #include "chrome/browser/sync/engine/get_commit_ids_command.h"
 #include "chrome/browser/sync/engine/net/server_connection_manager.h"
 #include "chrome/browser/sync/engine/post_commit_message_command.h"
 #include "chrome/browser/sync/engine/process_commit_response_command.h"
 #include "chrome/browser/sync/engine/process_updates_command.h"
@@ skipping 41 matching lines @@
       dirman_(dirman),
       command_channel_(NULL),
       model_safe_worker_(model_safe_worker),
       updates_source_(sync_pb::GetUpdatesCallerInfo::UNKNOWN),
       notifications_enabled_(false),
       pre_conflict_resolution_function_(NULL) {
   SyncerEvent shutdown = { SyncerEvent::SHUTDOWN_USE_WITH_CARE };
   syncer_event_channel_.reset(new SyncerEventChannel(shutdown));
   shutdown_channel_.reset(new ShutdownChannel(this));
 
+  extensions_monitor_ = new ExtensionsActivityMonitor(
+      ChromeThread::GetMessageLoop(ChromeThread::UI));
+
   ScopedDirLookup dir(dirman_, account_name_);
   // The directory must be good here.
   CHECK(dir.good());
 }
 
-Syncer::~Syncer() {}
+Syncer::~Syncer() {
+  MessageLoop* ui_loop = ChromeThread::GetMessageLoop(ChromeThread::UI);
+  if (ui_loop) {
+    ui_loop->DeleteSoon(FROM_HERE, extensions_monitor_);
+  } else {
+    NOTREACHED();
+    delete extensions_monitor_;
+  }
+  extensions_monitor_ = NULL;
+}
 
 void Syncer::RequestNudge(int milliseconds) {
   SyncerEvent event;
   event.what_happened = SyncerEvent::REQUEST_SYNC_NUDGE;
   event.nudge_delay_milliseconds = milliseconds;
   channel()->NotifyListeners(event);
 }
 
 bool Syncer::SyncShare() {
   SyncProcessState state(dirman_, account_name_, connection_manager_,
                          &resolver_, syncer_event_channel_.get(),
                          model_safe_worker());
   return SyncShare(&state);
 }
 
 bool Syncer::SyncShare(SyncProcessState* process_state) {
   SyncCycleState cycle_state;
   SyncerSession session(&cycle_state, process_state);
   session.set_source(TestAndSetUpdatesSource());
   session.set_notifications_enabled(notifications_enabled());
+  // This isn't perfect, as we can end up bundling extensions activity
+  // intended for the next session into the current one.  We could do a
+  // test-and-reset as with the source, but note that also falls short if
+  // the commit request fails (due to lost connection, for example), as we will
+  // fall all the way back to the syncer thread main loop in that case, and
+  // wind up creating a new session when a connection is established, losing
+  // the records set here on the original attempt.  This should provide us
+  // with the right data "most of the time", and we're only using this for
+  // analysis purposes, so Law of Large Numbers FTW.
+  extensions_monitor_->GetAndClearRecords(
+      session.mutable_extensions_activity());
   SyncShare(&session, SYNCER_BEGIN, SYNCER_END);
   return session.HasMoreToSync();
 }
 
 bool Syncer::SyncShare(SyncerStep first_step, SyncerStep last_step) {
   SyncCycleState cycle_state;
   SyncProcessState state(dirman_, account_name_, connection_manager_,
                          &resolver_, syncer_event_channel_.get(),
                          model_safe_worker());
   SyncerSession session(&cycle_state, &state);
@@ skipping 93 matching lines @@
       }
       case POST_COMMIT_MESSAGE: {
         LOG(INFO) << "Posting a commit request";
         PostCommitMessageCommand post_commit_command;
         post_commit_command.Execute(session);
         next_step = PROCESS_COMMIT_RESPONSE;
         break;
       }
       case PROCESS_COMMIT_RESPONSE: {
         LOG(INFO) << "Processing the commit response";
-        ProcessCommitResponseCommand process_response_command;
+        ProcessCommitResponseCommand process_response_command(
+            extensions_monitor_);
         process_response_command.Execute(session);
         next_step = BUILD_AND_PROCESS_CONFLICT_SETS;
         break;
       }
       case BUILD_AND_PROCESS_CONFLICT_SETS: {
         LOG(INFO) << "Building and Processing Conflict Sets";
         BuildAndProcessConflictSetsCommand build_process_conflict_sets;
         build_process_conflict_sets.Execute(session);
         if (session->conflict_sets_built())
           next_step = SYNCER_END;
@@ skipping 112 matching lines @@
                       entry.id_string().c_str(),
                       entry.parent_id_string().c_str(),
                       entry.version(),
                       entry.mtime(), ServerTimeToClientTime(entry.mtime()),
                       entry.ctime(), ServerTimeToClientTime(entry.ctime()),
                       entry.name().c_str(), entry.sync_timestamp(),
                       entry.deleted() ? "deleted, ":"");
 }
 
 }  // namespace browser_sync