Propagate the result of AmountOfFreeSpace to JS and show it in chrome://drive-internals.

chrome/browser/ui/webui/chromeos/drive_internals_ui.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/ui/webui/chromeos/drive_internals_ui.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "base/memory/weak_ptr.h"
+#include "base/path_service.h"
+#include "base/sys_info.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_auth_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_cache.h"
 #include "chrome/browser/chromeos/gdata/gdata_documents_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_file_system_interface.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/browser_resources.h"
 
+using content::BrowserThread;
+
 namespace chromeos {
 
 namespace {
 
 // Gets metadata of all files and directories in |root_path|
 // recursively. Stores the result as a list of dictionaries like:
 //
 // [{ path: 'GCache/v1/tmp/<resource_id>',
 //    size: 12345,
 //    is_directory: false,
@@ skipping 39 matching lines @@
 
   // Convert |files| into |gcache_contents|.
   for (std::map<FilePath, DictionaryValue*>::const_iterator
            iter = files.begin(); iter != files.end(); ++iter) {
     gcache_contents->Append(iter->second);
   }
 
   gcache_summary->SetDouble("total_size", total_size);
 }
 
+// Gets the available disk space for the path |home_path|.
+void GetFreeDiskSpace(const FilePath& home_path,
+                      base::DictionaryValue* local_storage_summary) {
+  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(local_storage_summary);
+
+  const int64 free_space = base::SysInfo::AmountOfFreeDiskSpace(home_path);
+  local_storage_summary->SetDouble("free_space", free_space);
+}
+
 // Formats |entry| into text.
 std::string FormatEntry(const FilePath& path,
                         const gdata::GDataEntryProto& entry) {
   using base::StringAppendF;
   using gdata::util::FormatTimeAsString;
 
   std::string out;
   StringAppendF(&out, "%s\n", path.AsUTF8Unsafe().c_str());
   StringAppendF(&out, "  title: %s\n", entry.title().c_str());
   StringAppendF(&out, "  resource_id: %s\n", entry.resource_id().c_str());
@@ skipping 76 matching lines @@
 
   // Called when GetResourceIdsOfAllFilesOnUIThread() is complete.
   void OnGetResourceIdsOfAllFiles(
       const std::vector<std::string>& resource_ids);
 
   // Called when GetCacheEntryOnUIThread() is complete.
   void OnGetCacheEntry(const std::string& resource_id,
                        bool success,
                        const gdata::GDataCacheEntry& cache_entry);
 
+  // Called when GetFreeDiskSpace() is complete.
+  void OnGetFreeDiskSpace(base::DictionaryValue* local_storage_summary);
+
   // The number of pending ReadDirectoryByPath() calls.
   int num_pending_reads_;
   base::WeakPtrFactory<DriveInternalsWebUIHandler> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveInternalsWebUIHandler);
 };
 
 void DriveInternalsWebUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "pageLoaded",
       base::Bind(&DriveInternalsWebUIHandler::OnPageLoaded,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 gdata::GDataSystemService* DriveInternalsWebUIHandler::GetSystemService() {
   Profile* profile = Profile::FromWebUI(web_ui());
   return gdata::GDataSystemServiceFactory::GetForProfile(profile);
 }
 
 void DriveInternalsWebUIHandler::OnPageLoaded(const base::ListValue* args) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   gdata::GDataSystemService* system_service = GetSystemService();
   // |system_service| may be NULL in the guest/incognito mode.
   if (!system_service)
     return;
 
   gdata::DocumentsServiceInterface* documents_service =
       system_service->docs_service();
   DCHECK(documents_service);
 
   // Update the auth status section.
   base::DictionaryValue auth_status;
   auth_status.SetBoolean("has-refresh-token",
                          documents_service->HasRefreshToken());
   auth_status.SetBoolean("has-access-token",
                          documents_service->HasAccessToken());
   web_ui()->CallJavascriptFunction("updateAuthStatus", auth_status);
 
   // Start updating the GCache contents section.
   Profile* profile = Profile::FromWebUI(web_ui());
   const FilePath root_path =
       gdata::GDataCache::GetCacheRootPath(profile);
   base::ListValue* gcache_contents = new ListValue;
   base::DictionaryValue* gcache_summary = new DictionaryValue;
-  content::BrowserThread::PostBlockingPoolTaskAndReply(
+  BrowserThread::PostBlockingPoolTaskAndReply(
       FROM_HERE,
       base::Bind(&GetGCacheContents,
                  root_path,
                  gcache_contents,
                  gcache_summary),
       base::Bind(&DriveInternalsWebUIHandler::OnGetGCacheContents,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(gcache_contents),
                  base::Owned(gcache_summary)));
+
+  // Propagate the amount of local free space in bytes.
+  FilePath home_path;
+  if (PathService::Get(base::DIR_HOME, &home_path)) {
+    base::DictionaryValue* local_storage_summary = new DictionaryValue;
+    BrowserThread::PostBlockingPoolTaskAndReply(
+        FROM_HERE,
+        base::Bind(&GetFreeDiskSpace, home_path, local_storage_summary),
+        base::Bind(&DriveInternalsWebUIHandler::OnGetFreeDiskSpace,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   base::Owned(local_storage_summary)));
+  } else {
+    LOG(ERROR) << "Home directory not found";
+  }
 }
 
 void DriveInternalsWebUIHandler::OnGetGCacheContents(
     base::ListValue* gcache_contents,
     base::DictionaryValue* gcache_summary) {
   DCHECK(gcache_contents);
   DCHECK(gcache_summary);
   web_ui()->CallJavascriptFunction("updateGCacheContents",
                                    *gcache_contents,
                                    *gcache_summary);
@@ skipping 84 matching lines @@
   value.SetString("md5", cache_entry.md5());
   value.SetBoolean("is_present", cache_entry.is_present());
   value.SetBoolean("is_pinned", cache_entry.is_pinned());
   value.SetBoolean("is_dirty", cache_entry.is_dirty());
   value.SetBoolean("is_mounted", cache_entry.is_mounted());
   value.SetBoolean("is_persistent", cache_entry.is_persistent());
 
   web_ui()->CallJavascriptFunction("updateCacheContents", value);
 }
 
+void DriveInternalsWebUIHandler::OnGetFreeDiskSpace(
+    base::DictionaryValue* local_storage_summary) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(local_storage_summary);
+
+  web_ui()->CallJavascriptFunction(
+      "updateLocalStorageUsage", *local_storage_summary);
+}
+
 }  // namespace
 
 DriveInternalsUI::DriveInternalsUI(content::WebUI* web_ui)
     : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new DriveInternalsWebUIHandler());
 
   ChromeWebUIDataSource* source =
       new ChromeWebUIDataSource(chrome::kChromeUIDriveInternalsHost);
   source->add_resource_path("drive_internals.css", IDR_DRIVE_INTERNALS_CSS);
   source->add_resource_path("drive_internals.js", IDR_DRIVE_INTERNALS_JS);
   source->set_default_resource(IDR_DRIVE_INTERNALS_HTML);
 
   Profile* profile = Profile::FromWebUI(web_ui);
   ChromeURLDataManager::AddDataSource(profile, source);
 }
 
 }  // namespace chromeos