gdata: Add Cache Contents section to 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 123 matching lines @@
                   file_specific_info.is_hosted_document());
   }
 
   return out;
 }
 
 // Class to handle messages from chrome://drive-internals.
 class DriveInternalsWebUIHandler : public content::WebUIMessageHandler {
  public:
   DriveInternalsWebUIHandler()
-      : weak_ptr_factory_(this) {
+      : num_pending_reads_(0),
+        weak_ptr_factory_(this) {
   }
 
   virtual ~DriveInternalsWebUIHandler() {
   }
 
  private:
   // 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);
 
   // 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);
+
+  // Called when GetCacheEntryOnUIThread() is complete.
+  void OnGetCacheEntry(const std::string& resource_id,
+                       bool success,
+                       const gdata::GDataCacheEntry& cache_entry);
+
+  // 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()));
 }
@@ skipping 39 matching lines @@
   DCHECK(gcache_contents);
   web_ui()->CallJavascriptFunction("updateGCacheContents", *gcache_contents);
 
   // 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(
       root_path,
       base::Bind(&DriveInternalsWebUIHandler::OnReadDirectoryByPath,
                  weak_ptr_factory_.GetWeakPtr(),
                  root_path));
 }
 
 void DriveInternalsWebUIHandler::OnReadDirectoryByPath(
     const FilePath& parent_path,
     gdata::GDataFileError error,
     bool hide_hosted_documents,
     scoped_ptr<gdata::GDataEntryProtoVector> entries) {
-  if (error != gdata::GDATA_FILE_OK)
-    return;
-  DCHECK(entries.get());
+  --num_pending_reads_;
+  if (error == gdata::GDATA_FILE_OK) {
+    DCHECK(entries.get());
 
-  std::string file_system_as_text;
-  for (size_t i = 0; i < entries->size(); ++i) {
-    const gdata::GDataEntryProto& entry = (*entries)[i];
-    const FilePath current_path = parent_path.Append(
-        FilePath::FromUTF8Unsafe(entry.base_name()));
+    std::string file_system_as_text;
+    for (size_t i = 0; i < entries->size(); ++i) {
+      const gdata::GDataEntryProto& entry = (*entries)[i];
+      const FilePath current_path = parent_path.Append(
+          FilePath::FromUTF8Unsafe(entry.base_name()));
 
-    file_system_as_text.append(FormatEntry(current_path, entry) + "\n");
+      file_system_as_text.append(FormatEntry(current_path, entry) + "\n");
 
-    if (entry.file_info().is_directory()) {
-      GetSystemService()->file_system()->ReadDirectoryByPath(
-          current_path,
-          base::Bind(&DriveInternalsWebUIHandler::OnReadDirectoryByPath,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     current_path));
+      if (entry.file_info().is_directory()) {
+        ++num_pending_reads_;
+        GetSystemService()->file_system()->ReadDirectoryByPath(
+            current_path,
+            base::Bind(&DriveInternalsWebUIHandler::OnReadDirectoryByPath,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       current_path));
+      }
     }
+
+    // There may be pending ReadDirectoryByPath() calls, but we can update
+    // the page with what we have now. This results in progressive
+    // updates, which is good for a large file system.
+    const base::StringValue value(file_system_as_text);
+    web_ui()->CallJavascriptFunction("updateFileSystemContents", value);
   }
 
-  // There may be pending ReadDirectoryByPath() calls, but we can update
-  // the page with what we have now. This results in progressive
-  // updates, which is good for a large file system.
-  const base::StringValue value(file_system_as_text);
-  web_ui()->CallJavascriptFunction("updateFileSystemContents", value);
+  // Start updating the cache contents section once all directories are
+  // processed.
+  if (num_pending_reads_ == 0) {
+    GetSystemService()->cache()->GetResourceIdsOfAllFilesOnUIThread(
+        base::Bind(&DriveInternalsWebUIHandler::OnGetResourceIdsOfAllFiles,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+}
+
+void DriveInternalsWebUIHandler::OnGetResourceIdsOfAllFiles(
+    const std::vector<std::string>& resource_ids) {
+  for (size_t i = 0; i < resource_ids.size(); ++i) {
+    const std::string& resource_id = resource_ids[i];
+    GetSystemService()->cache()->GetCacheEntryOnUIThread(
+        resource_id,
+        "",  // Don't check MD5.
+        base::Bind(&DriveInternalsWebUIHandler::OnGetCacheEntry,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   resource_id));
+  }
+}
+
+void DriveInternalsWebUIHandler::OnGetCacheEntry(
+    const std::string& resource_id,
+    bool success,
+    const gdata::GDataCacheEntry& cache_entry) {
+  if (!success) {
+    LOG(ERROR) << "Failed to get cache entry: " << resource_id;
+    return;
+  }
+
+  // Convert |cache_entry| into a dictionary.
+  base::DictionaryValue value;
+  value.SetString("resource_id", resource_id);
+  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);
 }
 
 }  // 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