Convert the PluginService interface to be an async wrapper around PluginList.

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It
@@ skipping 169 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/guid.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "content/browser/load_notification_details.h"
+#include "content/browser/plugin_service.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/common/child_process_info.h"
 #include "content/common/notification_service.h"
 #include "webkit/plugins/npapi/plugin_list.h"
 #include "webkit/plugins/webplugininfo.h"
 
 // TODO(port): port browser_distribution.h.
 #if !defined(OS_POSIX)
 #include "chrome/installer/util/browser_distribution.h"
 #endif
@@ skipping 116 matching lines @@
     MessageLoop::current()->PostTask(FROM_HERE, completion_);
   }
 
  private:
   ~MetricsMemoryDetails() {}
 
   Task* completion_;
   DISALLOW_COPY_AND_ASSIGN(MetricsMemoryDetails);
 };
 
-class MetricsService::InitTaskComplete : public Task {
- public:
-  explicit InitTaskComplete(
-      const std::string& hardware_class,
-      const std::vector<webkit::WebPluginInfo>& plugins)
-      : hardware_class_(hardware_class), plugins_(plugins) {}
-
-  virtual void Run() {
-    g_browser_process->metrics_service()->OnInitTaskComplete(
-        hardware_class_, plugins_);
-  }
-
- private:
-  std::string hardware_class_;
-  std::vector<webkit::WebPluginInfo> plugins_;
-};
-
-class MetricsService::InitTask : public Task {
- public:
-  explicit InitTask(MessageLoop* callback_loop)
-      : callback_loop_(callback_loop) {}
-
-  virtual void Run() {
-    std::vector<webkit::WebPluginInfo> plugins;
-    webkit::npapi::PluginList::Singleton()->GetPlugins(&plugins);
-    std::string hardware_class;  // Empty string by default.
-#if defined(OS_CHROMEOS)
-    chromeos::system::StatisticsProvider::GetInstance()->GetMachineStatistic(
-        "hardware_class", &hardware_class);
-#endif  // OS_CHROMEOS
-    callback_loop_->PostTask(FROM_HERE, new InitTaskComplete(
-        hardware_class, plugins));
-  }
-
- private:
-  MessageLoop* callback_loop_;
-};
-
 // static
 void MetricsService::RegisterPrefs(PrefService* local_state) {
   DCHECK(IsSingleThreaded());
   local_state->RegisterStringPref(prefs::kMetricsClientID, "");
   local_state->RegisterInt64Pref(prefs::kMetricsClientIDTimestamp, 0);
   local_state->RegisterInt64Pref(prefs::kStabilityLaunchTimeSec, 0);
   local_state->RegisterInt64Pref(prefs::kStabilityLastTimestampSec, 0);
   local_state->RegisterStringPref(prefs::kStabilityStatsVersion, "");
   local_state->RegisterInt64Pref(prefs::kStabilityStatsBuildTime, 0);
   local_state->RegisterBooleanPref(prefs::kStabilityExitedCleanly, true);
@@ skipping 64 matching lines @@
   local_state->ClearPref(prefs::kStabilityPluginStats);
 
   local_state->ClearPref(prefs::kMetricsInitialLogs);
   local_state->ClearPref(prefs::kMetricsOngoingLogs);
 }
 
 MetricsService::MetricsService()
     : recording_active_(false),
       reporting_active_(false),
       state_(INITIALIZED),
+      init_state_(INIT_SUBTASK_UNSTARTED),
       current_fetch_(NULL),
       io_thread_(NULL),
       idle_since_last_transmission_(false),
       next_window_id_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(log_sender_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(state_saver_factory_(this)),
       waiting_for_asynchronus_reporting_step_(false) {
   DCHECK(IsSingleThreaded());
   InitializeMetricsState();
 
@@ skipping 333 matching lines @@
   size_t switch_count = command_line->GetSwitches().size();
   UMA_HISTOGRAM_COUNTS_100("Chrome.CommandLineFlagCount", switch_count);
   UMA_HISTOGRAM_COUNTS_100("Chrome.CommandLineUncommonFlagCount",
                            switch_count - common_commands);
 
   // Kick off the process of saving the state (so the uptime numbers keep
   // getting updated) every n minutes.
   ScheduleNextStateSave();
 }
 
-void MetricsService::OnInitTaskComplete(
-    const std::string& hardware_class,
-    const std::vector<webkit::WebPluginInfo>& plugins) {
+void MetricsService::RunInitTasks() {
+  // Schedules a task on the file thread for execution of slower
+  // initialization steps (such as plugin list generation) necessary
+  // for sending the initial log.  This avoids blocking the main UI
+  // thread.
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+      base::Bind(&MetricsService::InitTaskGetHardwareClass,
+          base::Unretained(this),
+          MessageLoop::current()->message_loop_proxy()));
+
+  PluginService::GetInstance()->GetPlugins(
+      base::Bind(&MetricsService::OnInitTaskGotPluginInfo,
+          base::Unretained(this)));
+}
+
+void MetricsService::InitTaskGetHardwareClass(
+    base::MessageLoopProxy* target_loop) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  std::string hardware_class;
+#if defined(OS_CHROMEOS)
+  chromeos::system::StatisticsProvider::GetInstance()->GetMachineStatistic(
+      "hardware_class", &hardware_class);
+#endif  // OS_CHROMEOS
+
+  target_loop->PostTask(FROM_HERE,
+      base::Bind(&MetricsService::OnInitTaskGotHardwareClass,
+          base::Unretained(this), hardware_class));
+}
+
+void MetricsService::OnInitTaskGotHardwareClass(
+    const std::string& hardware_class) {
+  hardware_class_ = hardware_class;
+  init_state_ |= INIT_SUBTASK_HWCLASS;
+  OnInitTaskMaybeDone();
+}
+
+void MetricsService::OnInitTaskGotPluginInfo(
+    std::vector<webkit::WebPluginInfo> plugins) {
+  plugins_ = plugins;
+  init_state_ |= INIT_SUBTASK_PLUGINS;
+  OnInitTaskMaybeDone();
+}
+
+void MetricsService::OnInitTaskMaybeDone() {
   DCHECK(state_ == INIT_TASK_SCHEDULED);
-  hardware_class_ = hardware_class;
-  plugins_ = plugins;
+  if (state_ != INIT_TASK_SCHEDULED ||
+         (init_state_ & INIT_SUBTASK_ALL) != INIT_SUBTASK_ALL) {
+    return;
+  }
+
   io_thread_ = g_browser_process->io_thread();
-  if (state_ == INIT_TASK_SCHEDULED)
-    state_ = INIT_TASK_DONE;
+  state_ = INIT_TASK_DONE;
 }
 
 std::string MetricsService::GenerateClientID() {
   return guid::GenerateGUID();
 }
 
 //------------------------------------------------------------------------------
 // State save methods
 
 void MetricsService::ScheduleNextStateSave() {
@@ skipping 24 matching lines @@
 
 void MetricsService::StartRecording() {
   if (current_log_)
     return;
 
   current_log_ = new MetricsLog(client_id_, session_id_);
   if (state_ == INITIALIZED) {
     // We only need to schedule that run once.
     state_ = INIT_TASK_SCHEDULED;
 
-    // Schedules a task on the file thread for execution of slower
-    // initialization steps (such as plugin list generation) necessary
-    // for sending the initial log.  This avoids blocking the main UI
-    // thread.
-    g_browser_process->file_thread()->message_loop()->PostDelayedTask(FROM_HERE,
-        new InitTask(MessageLoop::current()),
+    MessageLoop::current()->PostDelayedTask(FROM_HERE,
+        base::Bind(&MetricsService::RunInitTasks, base::Unretained(this)),
         kInitializationDelaySeconds * 1000);
   }
 }
 
 void MetricsService::StopRecording() {
   if (!current_log_)
     return;
 
   // TODO(jar): Integrate bounds on log recording more consistently, so that we
   // can stop recording logs that are too big much sooner.
@@ skipping 880 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }