drive: Event logger for 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/command_line.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_cache.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_interface.h"
 #include "chrome/browser/chromeos/drive/drive_resource_metadata.h"
 #include "chrome/browser/chromeos/drive/drive_system_service.h"
+#include "chrome/browser/chromeos/drive/event_logger.h"
 #include "chrome/browser/google_apis/auth_service.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/drive_service_interface.h"
 #include "chrome/browser/google_apis/gdata_errorcode.h"
 #include "chrome/browser/google_apis/gdata_util.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 131 matching lines @@
   }
 
   return out;
 }
 
 // Class to handle messages from chrome://drive-internals.
 class DriveInternalsWebUIHandler : public content::WebUIMessageHandler {
  public:
   DriveInternalsWebUIHandler()
       : num_pending_reads_(0),
+        last_sent_event_id_(-1),
         weak_ptr_factory_(this) {
   }
 
   virtual ~DriveInternalsWebUIHandler() {
   }
 
  private:
   // WebUIMessageHandler override.
   virtual void RegisterMessages() OVERRIDE;
 
@@ skipping 13 matching lines @@
   void UpdateLocalMetadataSection(
       google_apis::DriveServiceInterface* drive_service);
   void UpdateDeltaUpdateStatusSection();
   void UpdateInFlightOperationsSection(
       google_apis::DriveServiceInterface* drive_service);
   void UpdateGCacheContentsSection();
   void UpdateFileSystemContentsSection(
       google_apis::DriveServiceInterface* drive_service);
   void UpdateLocalStorageUsageSection();
   void UpdateCacheContentsSection(drive::DriveCache* cache);
+  void UpdateEventLogSection(drive::EventLogger* event_logger);
 
   // Called when GetGCacheContents() is complete.
   void OnGetGCacheContents(base::ListValue* gcache_contents,
                            base::DictionaryValue* cache_summary);
 
   // Called when GetEntryInfoByPath() is complete.
   void OnGetEntryInfoByPath(const FilePath& path,
                             drive::DriveFileError error,
                             scoped_ptr<drive::DriveEntryProto> entry);
 
@@ skipping 12 matching lines @@
 
   // Called when GetAccountMetadata() call to DriveService is complete.
   void OnGetAccountMetadata(google_apis::GDataErrorCode status,
                             scoped_ptr<base::Value> data);
 
   // Called when the page requests periodic update.
   void OnPeriodicUpdate(const base::ListValue* args);
 
   // The number of pending ReadDirectoryByPath() calls.
   int num_pending_reads_;
+  // The last event sent to the JavaScript side.
+  int last_sent_event_id_;
+
   base::WeakPtrFactory<DriveInternalsWebUIHandler> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveInternalsWebUIHandler);
 };
 
 void DriveInternalsWebUIHandler::OnGetAccountMetadata(
     google_apis::GDataErrorCode status, scoped_ptr<base::Value> data) {
   if (status != google_apis::HTTP_SUCCESS) {
     LOG(ERROR) << "Failed to get account metadata";
     return;
   }
@@ skipping 76 matching lines @@
   UpdateDriveRelatedPreferencesSection();
   UpdateAuthStatusSection(drive_service);
   UpdateAccountMetadataSection(drive_service);
   UpdateLocalMetadataSection(drive_service);
   UpdateDeltaUpdateStatusSection();
   UpdateInFlightOperationsSection(drive_service);
   UpdateGCacheContentsSection();
   UpdateFileSystemContentsSection(drive_service);
   UpdateCacheContentsSection(cache);
   UpdateLocalStorageUsageSection();
+  UpdateEventLogSection(system_service->event_logger());
 }
 
 void DriveInternalsWebUIHandler::UpdateDriveRelatedFlagsSection() {
   const char* kDriveRelatedFlags[] = {
     switches::kDisableDrive,
     switches::kDisableDrivePrefetch,
     switches::kEnableDriveV2Api,
   };
 
   base::ListValue flags;
@@ skipping 185 matching lines @@
   }
 }
 
 void DriveInternalsWebUIHandler::UpdateCacheContentsSection(
     drive::DriveCache* cache) {
   cache->Iterate(base::Bind(&DriveInternalsWebUIHandler::UpdateCacheEntry,
                             weak_ptr_factory_.GetWeakPtr()),
                  base::Bind(&base::DoNothing));
 }
 
+void DriveInternalsWebUIHandler::UpdateEventLogSection(
+    drive::EventLogger* event_logger) {
+  const std::deque<drive::EventLogger::Event>& log =
+      event_logger->history();
+
+  base::ListValue list;
+  for (size_t i = 0; i < log.size(); ++i) {
+    // Skip events which were already sent.
+    if (log[i].id <= last_sent_event_id_)
+      continue;
+
+    base::DictionaryValue* dict = new DictionaryValue;
+    dict->SetString("key",
+        google_apis::util::FormatTimeAsStringLocaltime(log[i].when));
+    dict->SetString("value", log[i].what);
+    list.Append(dict);
+    last_sent_event_id_ = log[i].id;
+  }
+  if (!list.empty())
+    web_ui()->CallJavascriptFunction("updateEventLog", list);
+}
+
 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 75 matching lines @@
   drive::DriveSystemService* system_service = GetSystemService();
   // |system_service| may be NULL in the guest/incognito mode.
   if (!system_service)
     return;
 
   google_apis::DriveServiceInterface* drive_service =
       system_service->drive_service();
   DCHECK(drive_service);
 
   UpdateInFlightOperationsSection(drive_service);
+  UpdateEventLogSection(system_service->event_logger());
 }
 
 }  // 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