Drive: Show the total size of cache files at 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"
@@ skipping 21 matching lines @@
 // recursively. Stores the result as a list of dictionaries like:
 //
 // [{ path: 'GCache/v1/tmp/<resource_id>',
 //    size: 12345,
 //    is_directory: false,
 //    last_modified: '2005-08-09T09:57:00-08:00',
 //  },...]
 //
 // The list is sorted by the path.
 void GetGCacheContents(const FilePath& root_path,
-                       base::ListValue* gcache_contents) {
+                       base::ListValue* gcache_contents,
+                       base::DictionaryValue* gcache_summary) {
   using file_util::FileEnumerator;
   // Use this map to sort the result list by the path.
   std::map<FilePath, DictionaryValue*> files;
 
   const int options = (file_util::FileEnumerator::FILES |
                        file_util::FileEnumerator::DIRECTORIES |
                        file_util::FileEnumerator::SHOW_SYM_LINKS);
   FileEnumerator enumerator(
       root_path,
       true,  // recursive
       static_cast<FileEnumerator::FileType>(options));
 
+  int64 total_size = 0;
   for (FilePath current = enumerator.Next(); !current.empty();
        current = enumerator.Next()) {
     FileEnumerator::FindInfo find_info;
     enumerator.GetFindInfo(&find_info);
     int64 size = FileEnumerator::GetFilesize(find_info);
     const bool is_directory = FileEnumerator::IsDirectory(find_info);
     const bool is_symbolic_link = FileEnumerator::IsLink(find_info);
     const base::Time last_modified =
         FileEnumerator::GetLastModifiedTime(find_info);
 
     base::DictionaryValue* entry = new base::DictionaryValue;
     entry->SetString("path", current.value());
     // Use double instead of integer for large files.
     entry->SetDouble("size", size);
     entry->SetBoolean("is_directory", is_directory);
     entry->SetBoolean("is_symbolic_link", is_symbolic_link);
     entry->SetString("last_modified",
                      gdata::util::FormatTimeAsString(last_modified));
+    files[current] = entry;
 
-    files[current] = entry;
+    total_size += size;
   }
 
   // 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);
 }
 
 // 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());
@@ skipping 60 matching lines @@
   // WebUIMessageHandler override.
   virtual void RegisterMessages() OVERRIDE;
 
   // Returns a GDataSystemService.
   gdata::GDataSystemService* GetSystemService();
 
   // Called when the page is first loaded.
   void OnPageLoaded(const base::ListValue* args);
 
   // Called when GetGCacheContents() is complete.
-  void OnGetGCacheContents(base::ListValue* gcache_contents);
+  void OnGetGCacheContents(base::ListValue* gcache_contents,
+                           base::DictionaryValue* cache_summary);
 
   // Called when ReadDirectoryByPath() is complete.
   void OnReadDirectoryByPath(const FilePath& parent_path,
                              gdata::GDataFileError error,
                              bool hide_hosted_documents,
                              scoped_ptr<gdata::GDataEntryProtoVector> entries);
 
   // Called when GetResourceIdsOfAllFilesOnUIThread() is complete.
   void OnGetResourceIdsOfAllFiles(
       const std::vector<std::string>& resource_ids);
@@ skipping 37 matching lines @@
                          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(
       FROM_HERE,
-      base::Bind(&GetGCacheContents, root_path, gcache_contents),
+      base::Bind(&GetGCacheContents,
+                 root_path,
+                 gcache_contents,
+                 gcache_summary),
       base::Bind(&DriveInternalsWebUIHandler::OnGetGCacheContents,
                  weak_ptr_factory_.GetWeakPtr(),
-                 base::Owned(gcache_contents)));
+                 base::Owned(gcache_contents),
+                 base::Owned(gcache_summary)));
 }
 
 void DriveInternalsWebUIHandler::OnGetGCacheContents(
-    base::ListValue* gcache_contents) {
+    base::ListValue* gcache_contents,
+    base::DictionaryValue* gcache_summary) {
   DCHECK(gcache_contents);
-  web_ui()->CallJavascriptFunction("updateGCacheContents", *gcache_contents);
+  DCHECK(gcache_summary);
+  web_ui()->CallJavascriptFunction("updateGCacheContents",
+                                   *gcache_contents,
+                                   *gcache_summary);
 
   // Start updating the file system tree section, if we have access token.
   gdata::GDataSystemService* system_service = GetSystemService();
   if (!system_service->docs_service()->HasAccessToken())
     return;
 
   // Start rendering the file system tree as text.
   const FilePath root_path = FilePath(gdata::kGDataRootDirectory);
   ++num_pending_reads_;
   system_service->file_system()->ReadDirectoryByPath(
@@ skipping 91 matching lines @@
       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