Add severity info to drive::EventLogger.

chrome/browser/chromeos/drive/change_list_loader.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/drive/change_list_loader.h"
 
 #include <set>
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
@@ skipping 54 matching lines @@
     // There is in-flight loading. So keep the callback here, and check for
     // updates when the in-flight loading is completed.
     pending_update_check_callback_ = callback;
     return;
   }
 
   if (loaded_) {
     // We only start to check for updates iff the load is done.
     // I.e., we ignore checking updates if not loaded to avoid starting the
     // load without user's explicit interaction (such as opening Drive).
-    util::Log("Checking for updates");
+    util::Log(logging::LOG_INFO, "Checking for updates");
     Load(DirectoryFetchInfo(), callback);
   }
 }
 
 void ChangeListLoader::LoadIfNeeded(
     const DirectoryFetchInfo& directory_fetch_info,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
@@ skipping 119 matching lines @@
     Load(DirectoryFetchInfo(),
          base::ResetAndReturn(&pending_update_check_callback_));
   }
 }
 
 void ChangeListLoader::OnDirectoryLoadComplete(
     const DirectoryFetchInfo& directory_fetch_info,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  util::Log("Fast-fetch complete: %s => %s",
+  util::Log(logging::LOG_INFO,
+            "Fast-fetch complete: %s => %s",
             directory_fetch_info.ToString().c_str(),
             FileErrorToString(error).c_str());
   const std::string& resource_id = directory_fetch_info.resource_id();
   LoadCallbackMap::iterator it = pending_load_callback_.find(resource_id);
   if (it != pending_load_callback_.end()) {
     DVLOG(1) << "Running callback for " << resource_id;
     const std::vector<FileOperationCallback>& callbacks = it->second;
     for (size_t i = 0; i < callbacks.size(); ++i) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
@@ skipping 207 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!directory_fetch_info.empty());
 
   int64 directory_changestamp = std::max(directory_fetch_info.changestamp(),
                                          local_changestamp);
 
   // We may not fetch from the server at all if the local metadata is new
   // enough, but we log this message here, so "Fast-fetch start" and
   // "Fast-fetch complete" always match.
   // TODO(satorux): Distinguish the "not fetching at all" case.
-  util::Log("Fast-fetch start: %s; Server changestamp: %s",
+  util::Log(logging::LOG_INFO,
+            "Fast-fetch start: %s; Server changestamp: %s",
             directory_fetch_info.ToString().c_str(),
             base::Int64ToString(last_known_remote_changestamp_).c_str());
 
   // If the directory's changestamp is up-to-date, just schedule to run the
   // callback, as there is no need to fetch the directory.
   // Note that |last_known_remote_changestamp_| is 0 when it is not received
   // yet. In that case we conservatively assume that we need to fetch.
   if (last_known_remote_changestamp_ > 0 &&
       directory_changestamp >= last_known_remote_changestamp_) {
     callback.Run(FILE_ERROR_OK);
@@ skipping 169 matching lines @@
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   ChangeListProcessor* change_list_processor =
       new ChangeListProcessor(resource_metadata_);
   // Don't send directory content change notification while performing
   // the initial content retrieval.
   const bool should_notify_changed_directories = is_delta_update;
 
-  util::Log("Apply change lists (is delta: %d)", is_delta_update);
+  util::Log(logging::LOG_INFO,
+            "Apply change lists (is delta: %d)",
+            is_delta_update);
   blocking_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&ChangeListProcessor::Apply,
                  base::Unretained(change_list_processor),
                  base::Passed(&about_resource),
                  base::Passed(&change_lists),
                  is_delta_update),
       base::Bind(&ChangeListLoader::UpdateFromChangeListAfterApply,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(change_list_processor),
                  should_notify_changed_directories,
                  base::Time::Now(),
                  callback));
 }
 
 void ChangeListLoader::UpdateFromChangeListAfterApply(
     ChangeListProcessor* change_list_processor,
     bool should_notify_changed_directories,
     base::Time start_time,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(change_list_processor);
   DCHECK(!callback.is_null());
 
   const base::TimeDelta elapsed = base::Time::Now() - start_time;
-  util::Log("Change lists applied (elapsed time: %sms)",
+  util::Log(logging::LOG_INFO,
+            "Change lists applied (elapsed time: %sms)",
             base::Int64ToString(elapsed.InMilliseconds()).c_str());
 
   if (should_notify_changed_directories) {
     for (std::set<base::FilePath>::iterator dir_iter =
             change_list_processor->changed_dirs().begin();
         dir_iter != change_list_processor->changed_dirs().end();
         ++dir_iter) {
       FOR_EACH_OBSERVER(ChangeListLoaderObserver, observers_,
                         OnDirectoryChanged(*dir_iter));
     }
   }
 
   callback.Run();
 }
 
 }  // namespace internal
 }  // namespace drive