Added asynchronous notification of readiness to the StatisticsProvider, and

chrome/browser/chromeos/system/statistics_provider.cc

 // 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.
 
 #include "chrome/browser/chromeos/system/statistics_provider.h"
 
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
+#include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
 #include "base/chromeos/chromeos_version.h"
 #include "chrome/browser/chromeos/system/name_value_pairs_parser.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
@@ skipping 41 matching lines @@
 
 }  // namespace
 
 // The StatisticsProvider implementation used in production.
 class StatisticsProviderImpl : public StatisticsProvider {
  public:
   // StatisticsProvider implementation:
   virtual bool GetMachineStatistic(const std::string& name,
                                    std::string* result) OVERRIDE;
 
+  virtual void WhenReady(const base::Closure& callback) OVERRIDE;
+
   static StatisticsProviderImpl* GetInstance();
 
  private:
   friend struct DefaultSingletonTraits<StatisticsProviderImpl>;
 
   StatisticsProviderImpl();
 
   // Starts loading the machine statistcs.
   void StartLoadingMachineStatistics();
 
   // Loads the machine statistcs by examining the system.
   void LoadMachineStatistics();
 
+  // Invokes all the callbacks.
+  void NotifyOnUI();
+
   NameValuePairsParser::NameValueMap machine_info_;
   base::WaitableEvent on_statistics_loaded_;
+  std::vector<base::Closure> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(StatisticsProviderImpl);
 };
 
 bool StatisticsProviderImpl::GetMachineStatistic(
     const std::string& name, std::string* result) {
   VLOG(1) << "Statistic is requested for " << name;
   // Block if the statistics are not loaded yet. Per LOG(WARNING) below,
   // the statistics are loaded before requested as of now. For regular
   // sessions (i.e. not OOBE), statistics are first requested when the
@@ skipping 11 matching lines @@
   }
 
   NameValuePairsParser::NameValueMap::iterator iter = machine_info_.find(name);
   if (iter != machine_info_.end()) {
     *result = iter->second;
     return true;
   }
   return false;
 }
 
+void StatisticsProviderImpl::WhenReady(const base::Closure& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (on_statistics_loaded_.IsSignaled()) {
+    // Don't assume the caller is re-entrant.
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
+  } else {
+    callbacks_.push_back(callback);
+  }
+}
+
 // manual_reset needs to be true, as we want to keep the signaled state.
 StatisticsProviderImpl::StatisticsProviderImpl()
     : on_statistics_loaded_(true  /* manual_reset */,
                             false /* initially_signaled */) {
   StartLoadingMachineStatistics();
 }
 
 void StatisticsProviderImpl::StartLoadingMachineStatistics() {
   VLOG(1) << "Started loading statistics";
   CHECK(BrowserThread::IsMessageLoopValid(BrowserThread::FILE))
@@ skipping 29 matching lines @@
                                    kEchoCouponDelim);
   parser.GetNameValuePairsFromFile(FilePath(kMachineOSInfoFile),
                                    kMachineOSInfoEq,
                                    kMachineOSInfoDelim);
   parser.GetNameValuePairsFromFile(FilePath(kVpdFile), kVpdEq, kVpdDelim);
 
   // Finished loading the statistics.
   on_statistics_loaded_.Signal();
   VLOG(1) << "Finished loading statistics";
 
+  // Any callbacks registed before Signal() are in |callbacks_|. Any registed
+  // after Signal() will be immediately posted. NotifyOnUI() posts the callbacks
+  // in |callbacks_| from the UI loop.
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&StatisticsProviderImpl::NotifyOnUI,
+                                     base::Unretained(this)));
+
 #if defined(GOOGLE_CHROME_BUILD)
   // TODO(kochi): This is for providing a channel information to
   // chrome::VersionInfo::GetChannel()/GetVersionStringModifier(),
   // but this is still late for some early customers such as
   // prerender::ConfigurePrefetchAndPrerender() and
   // ThreadWatcherList::ParseCommandLine().
   // See http://crbug.com/107333 .
   const char kChromeOSReleaseTrack[] = "CHROMEOS_RELEASE_TRACK";
   std::string channel;
   if (GetMachineStatistic(kChromeOSReleaseTrack, &channel)) {
       chrome::VersionInfo::SetChannel(channel);
       // Set the product channel for crash reports.  We can't just do this in
       // ChromeBrowserMainParts::PreCreateThreads like we do for Linux because
       // the FILE thread hasn't been created yet there so we can't possibly
       // have read this yet.  Note that this string isn't exactly the same as
       // 'channel', it's been parsed to be consistent with other platforms
       // (eg. "canary-channel" becomes "canary", "testimage-channel" becomes
       // "unknown").
       child_process_logging::SetChannel(
           chrome::VersionInfo::GetVersionStringModifier());
   }
 #endif
 }
 
+void StatisticsProviderImpl::NotifyOnUI() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  for (std::vector<base::Closure>::iterator it = callbacks_.begin();
+       it != callbacks_.end(); ++it) {
+    it->Run();
+  }
+  callbacks_.clear();
+}
+
 StatisticsProviderImpl* StatisticsProviderImpl::GetInstance() {
   return Singleton<StatisticsProviderImpl,
                    DefaultSingletonTraits<StatisticsProviderImpl> >::get();
 }
 
 // The stub StatisticsProvider implementation used on Linux desktop.
 class StatisticsProviderStubImpl : public StatisticsProvider {
  public:
   // StatisticsProvider implementation:
   virtual bool GetMachineStatistic(const std::string& name,
                                    std::string* result) OVERRIDE {
     return false;
   }
 
+  virtual void WhenReady(const base::Closure& callback) OVERRIDE {
+    callback.Run();
+  }
+
   static StatisticsProviderStubImpl* GetInstance() {
     return Singleton<StatisticsProviderStubImpl,
         DefaultSingletonTraits<StatisticsProviderStubImpl> >::get();
   }
 
  private:
   friend struct DefaultSingletonTraits<StatisticsProviderStubImpl>;
 
   StatisticsProviderStubImpl() {
   }
 
   DISALLOW_COPY_AND_ASSIGN(StatisticsProviderStubImpl);
 };
 
 StatisticsProvider* StatisticsProvider::GetInstance() {
   if (base::chromeos::IsRunningOnChromeOS()) {
     return StatisticsProviderImpl::GetInstance();
   } else {
     return StatisticsProviderStubImpl::GetInstance();
   }
 }
 
 }  // namespace system
 }  // namespace chromeos