Mojo: Make Channel::OnFatalError() less spammy.

Also:
* Remove RawChannel::Delegate::FATAL_ERROR_UNKNOWN (it was unused).
* Rename FATAL_ERROR_FAILED_{READ,WRITE} to simply
  FATAL_ERROR_{READ,WRITE}. (In addition to being redundant/verbose,
  "failed read" was a bit misleading: the error may well have been in
  *waiting* to read, not reading per se.)

R=yzshen@chromium.org

Review URL: https://codereview.chromium.org/315003005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@275141 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 40 insertions, 29 deletions

diff --git a/mojo/system/channel.cc b/mojo/system/channel.cc
index f0831a9b..a311695 100644
--- a/mojo/system/channel.cc
+++ b/mojo/system/channel.cc
@@ -293,7 +293,18 @@ void Channel::OnReadMessage(
 }
 
 void Channel::OnFatalError(FatalError fatal_error) {
-  LOG(WARNING) << "RawChannel fatal error (type " << fatal_error << ")";
+  switch (fatal_error) {
+    case FATAL_ERROR_READ:
+      // Most read errors aren't notable: they just reflect that the other side
+      // tore down the channel.
+      DVLOG(1) << "RawChannel fatal error (read)";
+      break;
+    case FATAL_ERROR_WRITE:
+      // Write errors are slightly notable: they probably shouldn't happen under
+      // normal operation (but maybe the other side crashed).
+      LOG(WARNING) << "RawChannel fatal error (write)";
+      break;
+  }
   Shutdown();
 }
 
diff --git a/mojo/system/raw_channel.cc b/mojo/system/raw_channel.cc
index 8ed6452..f7b8029 100644
--- a/mojo/system/raw_channel.cc
+++ b/mojo/system/raw_channel.cc
@@ -257,7 +257,7 @@ bool RawChannel::WriteMessage(scoped_ptr<MessageInTransit> message) {
         FROM_HERE,
         base::Bind(&RawChannel::CallOnFatalError,
                    weak_ptr_factory_.GetWeakPtr(),
-                   Delegate::FATAL_ERROR_FAILED_WRITE));
+                   Delegate::FATAL_ERROR_WRITE));
   }
 
   return result;
@@ -287,7 +287,7 @@ void RawChannel::OnReadCompleted(bool result, size_t bytes_read) {
   do {
     if (io_result != IO_SUCCEEDED) {
       read_stopped_ = true;
-      CallOnFatalError(Delegate::FATAL_ERROR_FAILED_READ);
+      CallOnFatalError(Delegate::FATAL_ERROR_READ);
       return;
     }
 
@@ -322,14 +322,14 @@ void RawChannel::OnReadCompleted(bool result, size_t bytes_read) {
         DCHECK(error_message);
         LOG(WARNING) << "Received invalid message: " << error_message;
         read_stopped_ = true;
-        CallOnFatalError(Delegate::FATAL_ERROR_FAILED_READ);
+        CallOnFatalError(Delegate::FATAL_ERROR_READ);
         return;
       }
 
       if (message_view.type() == MessageInTransit::kTypeRawChannel) {
         if (!OnReadMessageForRawChannel(message_view)) {
           read_stopped_ = true;
-          CallOnFatalError(Delegate::FATAL_ERROR_FAILED_READ);
+          CallOnFatalError(Delegate::FATAL_ERROR_READ);
           return;
         }
       } else {
@@ -349,7 +349,7 @@ void RawChannel::OnReadCompleted(bool result, size_t bytes_read) {
             if (!platform_handles) {
               LOG(WARNING) << "Invalid number of platform handles received";
               read_stopped_ = true;
-              CallOnFatalError(Delegate::FATAL_ERROR_FAILED_READ);
+              CallOnFatalError(Delegate::FATAL_ERROR_READ);
               return;
             }
           }
@@ -434,7 +434,7 @@ void RawChannel::OnWriteCompleted(bool result,
   }
 
   if (did_fail)
-    CallOnFatalError(Delegate::FATAL_ERROR_FAILED_WRITE);
+    CallOnFatalError(Delegate::FATAL_ERROR_WRITE);
 }
 
 void RawChannel::EnqueueMessageNoLock(scoped_ptr<MessageInTransit> message) {
diff --git a/mojo/system/raw_channel.h b/mojo/system/raw_channel.h
index 59600bf..965e109 100644
--- a/mojo/system/raw_channel.h
+++ b/mojo/system/raw_channel.h
@@ -49,9 +49,8 @@ class MOJO_SYSTEM_IMPL_EXPORT RawChannel {
   class MOJO_SYSTEM_IMPL_EXPORT Delegate {
    public:
     enum FatalError {
-      FATAL_ERROR_UNKNOWN = 0,
-      FATAL_ERROR_FAILED_READ,
-      FATAL_ERROR_FAILED_WRITE
+      FATAL_ERROR_READ = 0,
+      FATAL_ERROR_WRITE
     };
 
     // Called when a message is read. This may call |Shutdown()| (on the
@@ -64,10 +63,10 @@ class MOJO_SYSTEM_IMPL_EXPORT RawChannel {
     // being viable. This may call |Shutdown()| (on the |RawChannel()|), but
     // must not destroy it.
     //
-    // For each raw channel, at most one |FATAL_ERROR_FAILED_READ| and at most
-    // one |FATAL_ERROR_FAILED_WRITE| notification will be issued (both may be
-    // issued). After a |OnFatalError(FATAL_ERROR_FAILED_READ)|, there will be
-    // no further calls to |OnReadMessage()|.
+    // For each raw channel, at most one |FATAL_ERROR_READ| and at most one
+    // |FATAL_ERROR_WRITE| notification will be issued (both may be issued).
+    // After a |OnFatalError(FATAL_ERROR_READ)|, there will be no further calls
+    // to |OnReadMessage()|.
     virtual void OnFatalError(FatalError fatal_error) = 0;
 
    protected:
diff --git a/mojo/system/raw_channel_unittest.cc b/mojo/system/raw_channel_unittest.cc
index e110217..2a386833 100644
--- a/mojo/system/raw_channel_unittest.cc
+++ b/mojo/system/raw_channel_unittest.cc
@@ -112,7 +112,7 @@ class WriteOnlyRawChannelDelegate : public RawChannel::Delegate {
   }
   virtual void OnFatalError(FatalError fatal_error) OVERRIDE {
     // We'll get a read error when the connection is closed.
-    CHECK_EQ(fatal_error, FATAL_ERROR_FAILED_READ);
+    CHECK_EQ(fatal_error, FATAL_ERROR_READ);
   }
 
  private:
@@ -254,7 +254,7 @@ class ReadCheckerRawChannelDelegate : public RawChannel::Delegate {
   }
   virtual void OnFatalError(FatalError fatal_error) OVERRIDE {
     // We'll get a read error when the connection is closed.
-    CHECK_EQ(fatal_error, FATAL_ERROR_FAILED_READ);
+    CHECK_EQ(fatal_error, FATAL_ERROR_READ);
   }
 
   // Waits for all the messages (of sizes |expected_sizes_|) to be seen.
@@ -366,7 +366,7 @@ class ReadCountdownRawChannelDelegate : public RawChannel::Delegate {
   }
   virtual void OnFatalError(FatalError fatal_error) OVERRIDE {
     // We'll get a read error when the connection is closed.
-    CHECK_EQ(fatal_error, FATAL_ERROR_FAILED_READ);
+    CHECK_EQ(fatal_error, FATAL_ERROR_READ);
   }
 
   // Waits for all the messages to have been seen.
@@ -443,16 +443,17 @@ class FatalErrorRecordingRawChannelDelegate
   virtual ~FatalErrorRecordingRawChannelDelegate() {}
 
   virtual void OnFatalError(FatalError fatal_error) OVERRIDE {
-    if (fatal_error == FATAL_ERROR_FAILED_READ) {
-      ASSERT_TRUE(expecting_read_error_);
-      expecting_read_error_ = false;
-      got_read_fatal_error_event_.Signal();
-    } else if (fatal_error == FATAL_ERROR_FAILED_WRITE) {
-      ASSERT_TRUE(expecting_write_error_);
-      expecting_write_error_ = false;
-      got_write_fatal_error_event_.Signal();
-    } else {
-      ASSERT_TRUE(false);
+    switch (fatal_error) {
+      case FATAL_ERROR_READ:
+        ASSERT_TRUE(expecting_read_error_);
+        expecting_read_error_ = false;
+        got_read_fatal_error_event_.Signal();
+        break;
+      case FATAL_ERROR_WRITE:
+        ASSERT_TRUE(expecting_write_error_);
+        expecting_write_error_ = false;
+        got_write_fatal_error_event_.Signal();
+        break;
     }
   }
 
@@ -654,7 +655,7 @@ class ShutdownOnFatalErrorRawChannelDelegate : public RawChannel::Delegate {
 TEST_F(RawChannelTest, ShutdownOnFatalErrorRead) {
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass()));
   ShutdownOnFatalErrorRawChannelDelegate delegate(
-      rc.get(), RawChannel::Delegate::FATAL_ERROR_FAILED_READ);
+      rc.get(), RawChannel::Delegate::FATAL_ERROR_READ);
   io_thread()->PostTaskAndWait(FROM_HERE,
                                base::Bind(&InitOnIOThread, rc.get(),
                                           base::Unretained(&delegate)));
@@ -669,7 +670,7 @@ TEST_F(RawChannelTest, ShutdownOnFatalErrorRead) {
 TEST_F(RawChannelTest, ShutdownOnFatalErrorWrite) {
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass()));
   ShutdownOnFatalErrorRawChannelDelegate delegate(
-      rc.get(), RawChannel::Delegate::FATAL_ERROR_FAILED_WRITE);
+      rc.get(), RawChannel::Delegate::FATAL_ERROR_WRITE);
   io_thread()->PostTaskAndWait(FROM_HERE,
                                base::Bind(&InitOnIOThread, rc.get(),
                                           base::Unretained(&delegate)));