CPP bindings: DCHECK when a Callback is destructed without being invoked

mojo/public/cpp/bindings/tests/router_unittest.cc

 // Copyright 2014 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 <stdlib.h>
 #include <string.h>
 
 #include "mojo/public/cpp/bindings/lib/message_builder.h"
 #include "mojo/public/cpp/bindings/lib/message_queue.h"
 #include "mojo/public/cpp/bindings/lib/router.h"
@@ skipping 29 matching lines @@
 
   bool Accept(Message* message) override {
     queue_->Push(message);
     return true;
   }
 
  private:
   internal::MessageQueue* queue_;
 };
 
-class ResponseGenerator : public MessageReceiverWithResponder {
+class ResponseGenerator : public MessageReceiverWithResponderStatus {
  public:
   ResponseGenerator() {}
 
   bool Accept(Message* message) override { return false; }
 
   bool AcceptWithResponder(Message* message,
-                           MessageReceiver* responder) override {
+                           MessageReceiverWithStatus* responder) override {
     EXPECT_TRUE(message->has_flag(internal::kMessageExpectsResponse));
 
     bool result = SendResponse(
         message->name(), message->request_id(),
         reinterpret_cast<const char*>(message->payload()), responder);
+    EXPECT_TRUE(responder->IsValid());
     delete responder;
     return result;
   }
 
   bool SendResponse(uint32_t name,
                     uint64_t request_id,
                     const char* request_string,
                     MessageReceiver* responder) {
     Message response;
     std::string response_string(request_string);
     response_string += " world!";
     AllocResponseMessage(name, response_string.c_str(), request_id, &response);
 
     return responder->Accept(&response);
   }
 };
 
 class LazyResponseGenerator : public ResponseGenerator {
  public:
   LazyResponseGenerator() : responder_(nullptr), name_(0), request_id_(0) {}
 
   ~LazyResponseGenerator() override { delete responder_; }
 
   bool AcceptWithResponder(Message* message,
-                           MessageReceiver* responder) override {
+                           MessageReceiverWithStatus* responder) override {
     name_ = message->name();
     request_id_ = message->request_id();
     request_string_ =
         std::string(reinterpret_cast<const char*>(message->payload()));
     responder_ = responder;
     return true;
   }
 
   bool has_responder() const { return !!responder_; }
 
+  bool responder_is_valid() const { return responder_->IsValid(); }
+
   // Send the response and delete the responder.
   void CompleteWithResponse() { Complete(true); }
 
   // Delete the responder without sending a response.
   void CompleteWithoutResponse() { Complete(false); }
 
  private:
   // Completes the request handling by deleting responder_. Optionally
   // also sends a response.
   void Complete(bool send_response) {
     if (send_response) {
       SendResponse(name_, request_id_, request_string_.c_str(), responder_);
     }
     delete responder_;
     responder_ = nullptr;
   }
 
-  MessageReceiver* responder_;
+  MessageReceiverWithStatus* responder_;
   uint32_t name_;
   uint64_t request_id_;
   std::string request_string_;
 };
 
 class RouterTest : public testing::Test {
  public:
   RouterTest() {}
 
   void SetUp() override {
@@ skipping 128 matching lines @@
   AllocRequestMessage(1, "hello", &request);
 
   internal::MessageQueue message_queue;
   router0.AcceptWithResponder(&request, new MessageAccumulator(&message_queue));
   PumpMessages();
 
   // The request has been received but the response has not been sent yet.
   EXPECT_TRUE(message_queue.IsEmpty());
 
   // Send the response.
+  EXPECT_TRUE(generator.responder_is_valid());
   generator.CompleteWithResponse();
   PumpMessages();
 
   // Check the response.
   EXPECT_FALSE(message_queue.IsEmpty());
   Message response;
   message_queue.Pop(&response);
   EXPECT_EQ(std::string("hello world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
 
   // Send a second message on the pipe.
   Message request2;
   AllocRequestMessage(1, "hello again", &request2);
 
   router0.AcceptWithResponder(&request2,
                               new MessageAccumulator(&message_queue));
   PumpMessages();
 
   // The request has been received but the response has not been sent yet.
   EXPECT_TRUE(message_queue.IsEmpty());
 
   // Send the second response.
+  EXPECT_TRUE(generator.responder_is_valid());
   generator.CompleteWithResponse();
   PumpMessages();
 
   // Check the second response.
   EXPECT_FALSE(message_queue.IsEmpty());
   message_queue.Pop(&response);
   EXPECT_EQ(std::string("hello again world!"),
             std::string(reinterpret_cast<const char*>(response.payload())));
 }
 
@@ skipping 55 matching lines @@
 
     internal::MessageQueue message_queue;
     router0.AcceptWithResponder(&request,
                                 new MessageAccumulator(&message_queue));
 
     PumpMessages();
 
     EXPECT_TRUE(generator.has_responder());
   }
 
+  EXPECT_FALSE(generator.responder_is_valid());
   generator.CompleteWithResponse();  // This should end up doing nothing.
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo