diff --git a/base/base.gyp b/base/base.gyp
index 5ab29286417de..3655bdad94c21 100644
--- a/base/base.gyp
+++ b/base/base.gyp
@@ -161,6 +161,7 @@
'utf_string_conversions_unittest.cc',
'values_unittest.cc',
'version_unittest.cc',
+ 'vlog_unittest.cc',
'waitable_event_unittest.cc',
'waitable_event_watcher_unittest.cc',
'watchdog_unittest.cc',
diff --git a/base/base.gypi b/base/base.gypi
index 7c665869529d1..5450594fd0f27 100644
--- a/base/base.gypi
+++ b/base/base.gypi
@@ -291,6 +291,8 @@
'utf_string_conversions.h',
'values.cc',
'values.h',
+ 'vlog.cc',
+ 'vlog.h',
'waitable_event.h',
'waitable_event_posix.cc',
'waitable_event_watcher.h',
diff --git a/base/base_switches.cc b/base/base_switches.cc
index b5e145f2de4f6..49c6487a4b592 100644
--- a/base/base_switches.cc
+++ b/base/base_switches.cc
@@ -31,6 +31,16 @@ const char kNoMessageBox[] = "no-message-box";
// to the test framework that the current process is a child process.
const char kTestChildProcess[] = "test-child-process";
+// Gives the default maximal active V-logging level; 0 is the default.
+// Normally positive values are used for V-logging levels.
+const char kV[] = "v";
+
+// Gives the per-module maximal V-logging levels to override the value
+// given by --v. E.g. "my_module=2,foo*=3" would change the logging
+// level for all code in source files "my_module.*" and "foo*.*"
+// ("-inl" suffixes are also disregarded for this matching).
+const char kVModule[] = "vmodule";
+
// Will wait for 60 seconds for a debugger to come to attach to the process.
const char kWaitForDebugger[] = "wait-for-debugger";
diff --git a/base/base_switches.h b/base/base_switches.h
index 6fe38423a3b70..56b6bc966add6 100644
--- a/base/base_switches.h
+++ b/base/base_switches.h
@@ -17,6 +17,8 @@ extern const char kFullMemoryCrashReport[];
extern const char kNoErrorDialogs[];
extern const char kNoMessageBox[];
extern const char kTestChildProcess[];
+extern const char kV[];
+extern const char kVModule[];
extern const char kWaitForDebugger[];
} // namespace switches
diff --git a/base/logging.cc b/base/logging.cc
index 780da868af49a..a94d5f35e16e9 100644
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -51,10 +51,12 @@ typedef pthread_mutex_t* MutexHandle;
#include "base/process_util.h"
#include "base/string_piece.h"
#include "base/utf_string_conversions.h"
+#include "base/vlog.h"
namespace logging {
bool g_enable_dcheck = false;
+VlogInfo* g_vlog_info = NULL;
const char* const log_severity_names[LOG_NUM_SEVERITIES] = {
"INFO", "WARNING", "ERROR", "ERROR_REPORT", "FATAL" };
@@ -329,8 +331,20 @@ void BaseInitLoggingImpl(const PathChar* new_log_file,
LoggingDestination logging_dest,
LogLockingState lock_log,
OldFileDeletionState delete_old) {
+ CommandLine* command_line = CommandLine::ForCurrentProcess();
g_enable_dcheck =
- CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableDCHECK);
+ command_line->HasSwitch(switches::kEnableDCHECK);
+ delete g_vlog_info;
+ g_vlog_info = NULL;
+ // Don't bother initializing g_vlog_info unless we use one of the
+ // vlog switches.
+ if (command_line->HasSwitch(switches::kV) ||
+ command_line->HasSwitch(switches::kVModule)) {
+ g_vlog_info =
+ new VlogInfo(command_line->GetSwitchValueASCII(switches::kV),
+ command_line->GetSwitchValueASCII(switches::kVModule));
+ }
+
LoggingLock::Init(lock_log, new_log_file);
LoggingLock logging_lock;
@@ -367,6 +381,13 @@ int GetMinLogLevel() {
return min_log_level;
}
+int GetVlogLevelHelper(const char* file, size_t N) {
+ DCHECK_GT(N, 0U);
+ return g_vlog_info ?
+ g_vlog_info->GetVlogLevel(base::StringPiece(file, N - 1)) :
+ VlogInfo::kDefaultVlogLevel;
+}
+
void SetLogFilterPrefix(const char* filter) {
if (log_filter_prefix) {
delete log_filter_prefix;
diff --git a/base/logging.h b/base/logging.h
index 2084739faa0ca..72f7274eb208c 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -74,6 +74,39 @@
//
// which is syntactic sugar for {,D}LOG_IF(FATAL, assert fails) << assertion;
//
+// There are "verbose level" logging macros. They look like
+//
+// VLOG(1) << "I'm printed when you run the program with --v=1 or more";
+// VLOG(2) << "I'm printed when you run the program with --v=2 or more";
+//
+// These always log at the INFO log level (when they log at all).
+// The verbose logging can also be turned on module-by-module. For instance,
+// --vmodule=profile=2,icon_loader=1,browser_*=3 --v=0
+// will cause:
+// a. VLOG(2) and lower messages to be printed from profile.{h,cc}
+// b. VLOG(1) and lower messages to be printed from icon_loader.{h,cc}
+// c. VLOG(3) and lower messages to be printed from files prefixed with
+// "browser"
+// d. VLOG(0) and lower messages to be printed from elsewhere
+//
+// The wildcarding functionality shown by (c) supports both '*' (match
+// 0 or more characters) and '?' (match any single character) wildcards.
+//
+// There's also VLOG_IS_ON(n) "verbose level" condition macro. To be used as
+//
+// if (VLOG_IS_ON(2)) {
+// // do some logging preparation and logging
+// // that can't be accomplished with just VLOG(2) << ...;
+// }
+//
+// There is also a VLOG_IF "verbose level" condition macro for sample
+// cases, when some extra computation and preparation for logs is not
+// needed.
+//
+// VLOG_IF(1, (size > 1024))
+// << "I'm printed when size is more than 1024 and when you run the "
+// "program with --v=1 or more";
+//
// We also override the standard 'assert' to use 'DLOG_ASSERT'.
//
// Lastly, there is:
@@ -177,6 +210,15 @@ void SetMinLogLevel(int level);
// Gets the current log level.
int GetMinLogLevel();
+// Gets the current vlog level for the given file (usually taken from
+// __FILE__).
+template <size_t N>
+int GetVlogLevel(const char (&file)[N]) {
+ return GetVlogLevelHelper(file, N);
+}
+// Note that |N| is the size *with* the null terminator.
+int GetVlogLevelHelper(const char* file_start, size_t N);
+
// Sets the log filter prefix. Any log message below LOG_ERROR severity that
// doesn't start with this prefix with be silently ignored. The filter defaults
// to NULL (everything is logged) if this function is not called. Messages
@@ -279,13 +321,25 @@ const LogSeverity LOG_DFATAL_LEVEL = LOG_FATAL;
// impossible to stream something like a string directly to an unnamed
// ostream. We employ a neat hack by calling the stream() member
// function of LogMessage which seems to avoid the problem.
+//
+// We can't do any caching tricks with VLOG_IS_ON() like the
+// google-glog version since it requires GCC extensions. This means
+// that using the v-logging functions in conjunction with --vmodule
+// may be slow.
+#define VLOG_IS_ON(verboselevel) \
+ (logging::GetVlogLevel(__FILE__) >= (verboselevel))
#define LOG(severity) COMPACT_GOOGLE_LOG_ ## severity.stream()
#define SYSLOG(severity) LOG(severity)
+#define VLOG(verboselevel) LOG_IF(INFO, VLOG_IS_ON(verboselevel))
+
+// TODO(akalin): Add more VLOG variants, e.g. VPLOG.
#define LOG_IF(severity, condition) \
!(condition) ? (void) 0 : logging::LogMessageVoidify() & LOG(severity)
#define SYSLOG_IF(severity, condition) LOG_IF(severity, condition)
+#define VLOG_IF(verboselevel, condition) \
+ LOG_IF(INFO, (condition) && VLOG_IS_ON(verboselevel))
#define LOG_ASSERT(condition) \
LOG_IF(FATAL, !(condition)) << "Assert failed: " #condition ". "
diff --git a/base/string_util.cc b/base/string_util.cc
index c30db96a32ef7..c7268dca3bedd 100644
--- a/base/string_util.cc
+++ b/base/string_util.cc
@@ -1113,9 +1113,10 @@ struct NextCharUTF16 {
}
};
-bool MatchPattern(const std::string& eval, const std::string& pattern) {
- return MatchPatternT(eval.c_str(), eval.c_str() + eval.size(),
- pattern.c_str(), pattern.c_str() + pattern.size(),
+bool MatchPattern(const base::StringPiece& eval,
+ const base::StringPiece& pattern) {
+ return MatchPatternT(eval.data(), eval.data() + eval.size(),
+ pattern.data(), pattern.data() + pattern.size(),
0, NextCharUTF8());
}
diff --git a/base/string_util.h b/base/string_util.h
index 0b57b78858bb7..7079127dfeabc 100644
--- a/base/string_util.h
+++ b/base/string_util.h
@@ -558,7 +558,8 @@ bool ElideString(const std::wstring& input, int max_len, std::wstring* output);
// string can contain wildcards like * and ?
// The backslash character (\) is an escape character for * and ?
// We limit the patterns to having a max of 16 * or ? characters.
-bool MatchPattern(const std::string& string, const std::string& pattern);
+bool MatchPattern(const base::StringPiece& string,
+ const base::StringPiece& pattern);
bool MatchPattern(const string16& string, const string16& pattern);
// Hack to convert any char-like type to its unsigned counterpart.
diff --git a/base/vlog.cc b/base/vlog.cc
new file mode 100644
index 0000000000000..d6c3eb7f56fc5
--- /dev/null
+++ b/base/vlog.cc
@@ -0,0 +1,69 @@
+// Copyright (c) 2010 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 "base/vlog.h"
+
+#include "base/basictypes.h"
+#include "base/string_number_conversions.h"
+#include "base/string_split.h"
+#include "base/string_util.h"
+
+namespace logging {
+
+const int VlogInfo::kDefaultVlogLevel = 0;
+
+VlogInfo::VlogInfo(const std::string& v_switch,
+ const std::string& vmodule_switch)
+ : max_vlog_level_(kDefaultVlogLevel) {
+ typedef std::pair<std::string, std::string> KVPair;
+ if (!base::StringToInt(v_switch, &max_vlog_level_)) {
+ LOG(WARNING) << "Parsed v switch \""
+ << v_switch << "\" as " << max_vlog_level_;
+ }
+ std::vector<KVPair> kv_pairs;
+ if (!base::SplitStringIntoKeyValuePairs(
+ vmodule_switch, '=', ',', &kv_pairs)) {
+ LOG(WARNING) << "Could not fully parse vmodule switch \""
+ << vmodule_switch << "\"";
+ }
+ for (std::vector<KVPair>::const_iterator it = kv_pairs.begin();
+ it != kv_pairs.end(); ++it) {
+ int vlog_level = kDefaultVlogLevel;
+ if (!base::StringToInt(it->second, &vlog_level)) {
+ LOG(WARNING) << "Parsed vlog level for \""
+ << it->first << "=" << it->second
+ << "\" as " << vlog_level;
+ }
+ vmodule_levels_.push_back(std::make_pair(it->first, vlog_level));
+ }
+}
+
+int VlogInfo::GetVlogLevel(const base::StringPiece& file) {
+ if (!vmodule_levels_.empty()) {
+ base::StringPiece module(file);
+ base::StringPiece::size_type last_slash_pos =
+ module.find_last_of("\\/");
+ if (last_slash_pos != base::StringPiece::npos) {
+ module.remove_prefix(last_slash_pos + 1);
+ }
+ base::StringPiece::size_type extension_start = module.find('.');
+ module = module.substr(0, extension_start);
+ static const char kInlSuffix[] = "-inl";
+ static const int kInlSuffixLen = arraysize(kInlSuffix) - 1;
+ if (module.ends_with(kInlSuffix)) {
+ module.remove_suffix(kInlSuffixLen);
+ }
+ for (std::vector<VmodulePattern>::const_iterator it =
+ vmodule_levels_.begin(); it != vmodule_levels_.end(); ++it) {
+ // TODO(akalin): Use a less-heavyweight version of MatchPattern
+ // (we can pretty much assume we're dealing with ASCII).
+ if (MatchPattern(module, it->first)) {
+ return it->second;
+ }
+ }
+ }
+ return max_vlog_level_;
+}
+
+} // namespace
diff --git a/base/vlog.h b/base/vlog.h
new file mode 100644
index 0000000000000..faa62ecaa7375
--- /dev/null
+++ b/base/vlog.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2010 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.
+
+#ifndef BASE_VLOG_H_
+#define BASE_VLOG_H_
+#pragma once
+
+#include <cstddef>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/string_piece.h"
+
+namespace logging {
+
+// A helper class containing all the settings for vlogging.
+class VlogInfo {
+ public:
+ // |v_switch| gives the default maximal active V-logging level; 0 is
+ // the default. Normally positive values are used for V-logging
+ // levels.
+ //
+ // |vmodule_switch| gives the per-module maximal V-logging levels to
+ // override the value given by |v_switch|.
+ // E.g. "my_module=2,foo*=3" would change the logging level for all
+ // code in source files "my_module.*" and "foo*.*" ("-inl" suffixes
+ // are also disregarded for this matching).
+ VlogInfo(const std::string& v_switch,
+ const std::string& vmodule_switch);
+
+ // Returns the vlog level for a given file (usually taken from
+ // __FILE__).
+ int GetVlogLevel(const base::StringPiece& file);
+
+ static const int kDefaultVlogLevel;
+
+ private:
+ typedef std::pair<std::string, int> VmodulePattern;
+
+ int max_vlog_level_;
+ std::vector<VmodulePattern> vmodule_levels_;
+
+ DISALLOW_COPY_AND_ASSIGN(VlogInfo);
+};
+
+} // namespace logging
+
+#endif // BASE_VLOG_H_
diff --git a/base/vlog_unittest.cc b/base/vlog_unittest.cc
new file mode 100644
index 0000000000000..bb4872498f320
--- /dev/null
+++ b/base/vlog_unittest.cc
@@ -0,0 +1,105 @@
+// Copyright (c) 2010 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 "base/vlog.h"
+
+#include "base/basictypes.h"
+#include "base/logging.h"
+#include "base/time.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace logging {
+
+namespace {
+
+class VlogTest : public testing::Test {
+};
+
+TEST_F(VlogTest, NoVmodule) {
+ EXPECT_EQ(0, VlogInfo("", "").GetVlogLevel("test1"));
+ EXPECT_EQ(0, VlogInfo("0", "").GetVlogLevel("test2"));
+ EXPECT_EQ(0, VlogInfo("blah", "").GetVlogLevel("test3"));
+ EXPECT_EQ(0, VlogInfo("0blah1", "").GetVlogLevel("test4"));
+ EXPECT_EQ(1, VlogInfo("1", "").GetVlogLevel("test5"));
+ EXPECT_EQ(5, VlogInfo("5", "").GetVlogLevel("test6"));
+}
+
+TEST_F(VlogTest, Vmodule) {
+ const char kVSwitch[] = "-1";
+ const char kVModuleSwitch[] =
+ "foo=,bar=0,baz=blah,,qux=0blah1,quux=1,corge=5";
+ VlogInfo vlog_info(kVSwitch, kVModuleSwitch);
+ EXPECT_EQ(-1, vlog_info.GetVlogLevel("/path/to/grault.cc"));
+ EXPECT_EQ(0, vlog_info.GetVlogLevel("/path/to/foo.cc"));
+ EXPECT_EQ(0, vlog_info.GetVlogLevel("D:\\Path\\To\\bar-inl.mm"));
+ EXPECT_EQ(-1, vlog_info.GetVlogLevel("D:\\path\\to what/bar_unittest.m"));
+ EXPECT_EQ(0, vlog_info.GetVlogLevel("baz.h"));
+ EXPECT_EQ(0, vlog_info.GetVlogLevel("/another/path/to/qux.h"));
+ EXPECT_EQ(1, vlog_info.GetVlogLevel("/path/to/quux"));
+ EXPECT_EQ(5, vlog_info.GetVlogLevel("c:\\path/to/corge.h"));
+}
+
+#define BENCHMARK(iters, elapsed, code) \
+ do { \
+ base::TimeTicks start = base::TimeTicks::Now(); \
+ for (int i = 0; i < iters; ++i) code; \
+ base::TimeTicks end = base::TimeTicks::Now(); \
+ elapsed = end - start; \
+ double cps = iters / elapsed.InSecondsF(); \
+ LOG(INFO) << cps << " cps (" << elapsed.InSecondsF() \
+ << "s elapsed)"; \
+ } while (0)
+
+double GetSlowdown(const base::TimeDelta& base,
+ const base::TimeDelta& elapsed) {
+ return elapsed.InSecondsF() / base.InSecondsF();
+}
+
+
+TEST_F(VlogTest, Perf) {
+ const char* kVlogs[] = {
+ "/path/to/foo.cc",
+ "C:\\path\\to\\bar.h",
+ "/path/to/not-matched.mm",
+ "C:\\path\\to\\baz-inl.mm",
+ "C:\\path\\to\\qux.mm",
+ "/path/to/quux.mm",
+ "/path/to/another-not-matched.mm",
+ };
+ const int kVlogCount = arraysize(kVlogs);
+
+ base::TimeDelta null_elapsed;
+ {
+ VlogInfo null_vlog_info("", "");
+ BENCHMARK(10000000, null_elapsed, {
+ EXPECT_NE(-1, null_vlog_info.GetVlogLevel(kVlogs[i % kVlogCount]));
+ });
+ }
+
+ {
+ VlogInfo small_vlog_info("0", "foo=1,bar=2,baz=3,qux=4,quux=5");
+ base::TimeDelta elapsed;
+ BENCHMARK(10000000, elapsed, {
+ EXPECT_NE(-1, small_vlog_info.GetVlogLevel(kVlogs[i % kVlogCount]));
+ });
+ LOG(INFO) << "slowdown = " << GetSlowdown(null_elapsed, elapsed)
+ << "x";
+ }
+
+ {
+ VlogInfo pattern_vlog_info("0", "fo*=1,ba?=2,b*?z=3,*ux=4,?uux=5");
+ base::TimeDelta elapsed;
+ BENCHMARK(10000000, elapsed, {
+ EXPECT_NE(-1, pattern_vlog_info.GetVlogLevel(kVlogs[i % kVlogCount]));
+ });
+ LOG(INFO) << "slowdown = " << GetSlowdown(null_elapsed, elapsed)
+ << "x";
+ }
+}
+
+#undef BENCHMARK
+
+} // namespace
+
+} // namespace logging
diff --git a/chrome/browser/sync/notifier/cache_invalidation_packet_handler.cc b/chrome/browser/sync/notifier/cache_invalidation_packet_handler.cc
index 983d05fcc6a0d..d2930f30144df 100644
--- a/chrome/browser/sync/notifier/cache_invalidation_packet_handler.cc
+++ b/chrome/browser/sync/notifier/cache_invalidation_packet_handler.cc
@@ -46,17 +46,17 @@ class CacheInvalidationListenTask : public buzz::XmppTask {
virtual ~CacheInvalidationListenTask() {}
virtual int ProcessStart() {
- LOG(INFO) << "CacheInvalidationListenTask started";
+ VLOG(2) << "CacheInvalidationListenTask started";
return STATE_RESPONSE;
}
virtual int ProcessResponse() {
const buzz::XmlElement* stanza = NextStanza();
if (stanza == NULL) {
- LOG(INFO) << "CacheInvalidationListenTask blocked";
+ VLOG(2) << "CacheInvalidationListenTask blocked";
return STATE_BLOCKED;
}
- LOG(INFO) << "CacheInvalidationListenTask response received";
+ VLOG(2) << "CacheInvalidationListenTask response received";
std::string data;
if (GetCacheInvalidationIqPacketData(stanza, &data)) {
callback_->Run(data);
@@ -71,14 +71,14 @@ class CacheInvalidationListenTask : public buzz::XmppTask {
}
virtual bool HandleStanza(const buzz::XmlElement* stanza) {
- LOG(INFO) << "Stanza received: "
+ VLOG(1) << "Stanza received: "
<< notifier::XmlElementToString(*stanza);
if (IsValidCacheInvalidationIqPacket(stanza)) {
- LOG(INFO) << "Queueing stanza";
+ VLOG(2) << "Queueing stanza";
QueueStanza(stanza);
return true;
}
- LOG(INFO) << "Stanza skipped";
+ VLOG(2) << "Stanza skipped";
return false;
}
@@ -128,10 +128,10 @@ class CacheInvalidationSendMessageTask : public buzz::XmppTask {
scoped_ptr<buzz::XmlElement> stanza(
MakeCacheInvalidationIqPacket(to_jid_, task_id(), msg_,
seq_, sid_));
- LOG(INFO) << "Sending message: "
+ VLOG(1) << "Sending message: "
<< notifier::XmlElementToString(*stanza.get());
if (SendStanza(stanza.get()) != buzz::XMPP_RETURN_OK) {
- LOG(INFO) << "Error when sending message";
+ VLOG(2) << "Error when sending message";
return STATE_ERROR;
}
return STATE_RESPONSE;
@@ -140,23 +140,23 @@ class CacheInvalidationSendMessageTask : public buzz::XmppTask {
virtual int ProcessResponse() {
const buzz::XmlElement* stanza = NextStanza();
if (stanza == NULL) {
- LOG(INFO) << "CacheInvalidationSendMessageTask blocked...";
+ VLOG(2) << "CacheInvalidationSendMessageTask blocked...";
return STATE_BLOCKED;
}
- LOG(INFO) << "CacheInvalidationSendMessageTask response received: "
+ VLOG(2) << "CacheInvalidationSendMessageTask response received: "
<< notifier::XmlElementToString(*stanza);
// TODO(akalin): Handle errors here.
return STATE_DONE;
}
virtual bool HandleStanza(const buzz::XmlElement* stanza) {
- LOG(INFO) << "Stanza received: "
+ VLOG(1) << "Stanza received: "
<< notifier::XmlElementToString(*stanza);
if (!MatchResponseIq(stanza, to_jid_, task_id())) {
- LOG(INFO) << "Stanza skipped";
+ VLOG(2) << "Stanza skipped";
return false;
}
- LOG(INFO) << "Queueing stanza";
+ VLOG(2) << "Queueing stanza";
QueueStanza(stanza);
return true;
}
diff --git a/chrome/browser/sync/notifier/chrome_invalidation_client.cc b/chrome/browser/sync/notifier/chrome_invalidation_client.cc
index c407b403dc34c..8eb02f46a007a 100644
--- a/chrome/browser/sync/notifier/chrome_invalidation_client.cc
+++ b/chrome/browser/sync/notifier/chrome_invalidation_client.cc
@@ -96,7 +96,7 @@ void ChromeInvalidationClient::Invalidate(
invalidation::Closure* callback) {
DCHECK(non_thread_safe_.CalledOnValidThread());
DCHECK(invalidation::IsCallbackRepeatable(callback));
- LOG(INFO) << "Invalidate: " << InvalidationToString(invalidation);
+ VLOG(1) << "Invalidate: " << InvalidationToString(invalidation);
syncable::ModelType model_type;
if (ObjectIdToRealModelType(invalidation.object_id(), &model_type)) {
listener_->OnInvalidate(model_type);
@@ -112,7 +112,7 @@ void ChromeInvalidationClient::InvalidateAll(
invalidation::Closure* callback) {
DCHECK(non_thread_safe_.CalledOnValidThread());
DCHECK(invalidation::IsCallbackRepeatable(callback));
- LOG(INFO) << "InvalidateAll";
+ VLOG(1) << "InvalidateAll";
listener_->OnInvalidateAll();
RunAndDeleteClosure(callback);
}
@@ -121,7 +121,7 @@ void ChromeInvalidationClient::AllRegistrationsLost(
invalidation::Closure* callback) {
DCHECK(non_thread_safe_.CalledOnValidThread());
DCHECK(invalidation::IsCallbackRepeatable(callback));
- LOG(INFO) << "AllRegistrationsLost";
+ VLOG(1) << "AllRegistrationsLost";
registration_manager_->MarkAllRegistrationsLost();
RunAndDeleteClosure(callback);
}
@@ -131,7 +131,7 @@ void ChromeInvalidationClient::RegistrationLost(
invalidation::Closure* callback) {
DCHECK(non_thread_safe_.CalledOnValidThread());
DCHECK(invalidation::IsCallbackRepeatable(callback));
- LOG(INFO) << "RegistrationLost: " << ObjectIdToString(object_id);
+ VLOG(1) << "RegistrationLost: " << ObjectIdToString(object_id);
syncable::ModelType model_type;
if (ObjectIdToRealModelType(object_id, &model_type)) {
registration_manager_->MarkRegistrationLost(model_type);
diff --git a/jingle/notifier/base/xmpp_connection.cc b/jingle/notifier/base/xmpp_connection.cc
index c3597f9faf767..634ad5498be23 100644
--- a/jingle/notifier/base/xmpp_connection.cc
+++ b/jingle/notifier/base/xmpp_connection.cc
@@ -121,12 +121,12 @@ void XmppConnection::OnStateChange(buzz::XmppEngine::State state) {
void XmppConnection::OnInputLog(const char* data, int len) {
DCHECK(non_thread_safe_.CalledOnValidThread());
- LOG(INFO) << "XMPP Input: " << base::StringPiece(data, len);
+ VLOG(2) << "XMPP Input: " << base::StringPiece(data, len);
}
void XmppConnection::OnOutputLog(const char* data, int len) {
DCHECK(non_thread_safe_.CalledOnValidThread());
- LOG(INFO) << "XMPP Output: " << base::StringPiece(data, len);
+ VLOG(2) << "XMPP Output: " << base::StringPiece(data, len);
}
void XmppConnection::ClearClient() {