Update IPC message handling for SecurityKeyIpcClient class

remoting/host/security_key/security_key_ipc_client.cc

 // Copyright 2016 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 "remoting/host/security_key/security_key_ipc_client.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 23 matching lines @@
   if (!channel_handle_.is_valid()) {
     channel_handle_ = mojo::edk::CreateClientHandle(named_channel_handle_);
   }
   return channel_handle_.is_valid();
 }
 
 void SecurityKeyIpcClient::EstablishIpcConnection(
     const ConnectedCallback& connected_callback,
     const base::Closure& connection_error_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!connected_callback.is_null());
-  DCHECK(!connection_error_callback.is_null());
+  DCHECK(connected_callback);
+  DCHECK(connection_error_callback);
   DCHECK(!ipc_channel_);
 
   connected_callback_ = connected_callback;
   connection_error_callback_ = connection_error_callback;
 
   ConnectToIpcChannel();
 }
 
 bool SecurityKeyIpcClient::SendSecurityKeyRequest(
     const std::string& request_payload,
     const ResponseCallback& response_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!request_payload.empty());
-  DCHECK(!response_callback.is_null());
+  DCHECK(response_callback);
 
   if (!ipc_channel_) {
     LOG(ERROR) << "Request made before IPC connection was established.";
     return false;
   }
 
-  if (!response_callback_.is_null()) {
+  if (response_callback_) {
     LOG(ERROR)
         << "Request made while waiting for a response to a previous request.";
     return false;
   }
 
   response_callback_ = response_callback;
   return ipc_channel_->Send(
       new ChromotingRemoteSecurityKeyToNetworkMsg_Request(request_payload));
 }
 
@@ skipping 47 matching lines @@
         << peer_session_id;
     base::ResetAndReturn(&connection_error_callback_).Run();
     return;
   }
 #endif  // defined(OS_WIN)
 }
 
 void SecurityKeyIpcClient::OnChannelError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (!connection_error_callback_.is_null()) {
+  if (connection_error_callback_) {
     base::ResetAndReturn(&connection_error_callback_).Run();
   }
 }
 
 void SecurityKeyIpcClient::OnSecurityKeyResponse(
     const std::string& response_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!connection_error_callback_.is_null());
 
   if (!response_data.empty()) {
     base::ResetAndReturn(&response_callback_).Run(response_data);
   } else {
     LOG(ERROR) << "Invalid response received";
-    base::ResetAndReturn(&connection_error_callback_).Run();
+    if (connection_error_callback_) {
+      base::ResetAndReturn(&connection_error_callback_).Run();
+    }
   }
 }
 
 void SecurityKeyIpcClient::OnConnectionReady() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!connected_callback_.is_null());
+
+  if (!connected_callback_) {
+    LOG(ERROR) << "Unexpected ConnectionReady message received.";
+    if (connection_error_callback_) {
+      base::ResetAndReturn(&connection_error_callback_).Run();
+    }
+    return;
+  }
 
   base::ResetAndReturn(&connected_callback_).Run(/*connection_usable=*/true);
 }
 
 void SecurityKeyIpcClient::OnInvalidSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(!connected_callback_.is_null());
+
+  if (!connected_callback_) {
+    LOG(ERROR) << "Unexpected InvalidSession message received.";
+    if (connection_error_callback_) {
+      base::ResetAndReturn(&connection_error_callback_).Run();
+    }
+    return;
+  }
 
   base::ResetAndReturn(&connected_callback_).Run(/*connection_usable=*/false);
 }
 
 void SecurityKeyIpcClient::ConnectToIpcChannel() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Verify that any existing IPC connection has been closed.
   CloseIpcConnection();
 
   if (!channel_handle_.is_valid() && !CheckForSecurityKeyIpcServerChannel()) {
-    if (!connection_error_callback_.is_null()) {
+    if (connection_error_callback_) {
       base::ResetAndReturn(&connection_error_callback_).Run();
     }
     return;
   }
 
   ipc_channel_ = IPC::Channel::CreateClient(
       mojo::edk::ConnectToPeerProcess(std::move(channel_handle_)).release(),
       this);
   if (ipc_channel_->Connect()) {
     return;
   }
   ipc_channel_.reset();
 
-  if (!connection_error_callback_.is_null()) {
+  if (connection_error_callback_) {
     base::ResetAndReturn(&connection_error_callback_).Run();
   }
 }
 
 }  // namespace remoting