Make IPC::ChannelProxy test check filter events

ipc/ipc_channel_proxy_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 "build/build_config.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/pickle.h"
 #include "base/threading/thread.h"
 #include "ipc/ipc_message.h"
@@ skipping 65 matching lines @@
     channel_->Send(new IPC::Message(message));
     return true;
   }
 
  private:
   IPC::Channel* channel_;
 };
 
 class MessageCountFilter : public IPC::ChannelProxy::MessageFilter {
  public:
+  enum FilterEvent {
+    NONE,
+    FILTER_ADDED,
+    CHANNEL_CONNECTED,
+    CHANNEL_ERROR,
+    CHANNEL_CLOSING,
+    FILTER_REMOVED
+  };
   MessageCountFilter()
       : messages_received_(0),
         supported_message_class_(0),
         is_global_filter_(true),
-        filter_removed_(false),
+        last_filter_event_(NONE),
         message_filtering_enabled_(false) {}
 
   MessageCountFilter(uint32 supported_message_class)
       : messages_received_(0),
         supported_message_class_(supported_message_class),
         is_global_filter_(false),
-        filter_removed_(false),
+        last_filter_event_(NONE),
         message_filtering_enabled_(false) {}
 
+  virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
+    EXPECT_TRUE(channel);
+    EXPECT_EQ(NONE, last_filter_event_);
+    last_filter_event_ = FILTER_ADDED;
+  }
+
+  virtual void OnChannelConnected(int32_t peer_pid) OVERRIDE {
+    EXPECT_EQ(FILTER_ADDED, last_filter_event_);
+    EXPECT_NE(static_cast<int32_t>(base::kNullProcessId), peer_pid);
+    last_filter_event_ = CHANNEL_CONNECTED;
+  }
+
+  virtual void OnChannelError() OVERRIDE {
+    EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
+    last_filter_event_ = CHANNEL_ERROR;
+  }
+
+  virtual void OnChannelClosing() OVERRIDE {
+    // We may or may not have gotten OnChannelError; if not, the last event has
+    // to be OnChannelConnected.
+    if (last_filter_event_ != CHANNEL_ERROR)
+      EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
+    last_filter_event_ = CHANNEL_CLOSING;
+  }
+
   virtual void OnFilterRemoved() OVERRIDE {
-    EXPECT_FALSE(filter_removed_);
-    filter_removed_ = true;
+    // If the channel didn't get a chance to connect, we might see the
+    // OnFilterRemoved event with no other events preceding it. We still want
+    // OnFilterRemoved to be called to allow for deleting the Filter.
+    if (last_filter_event_ != NONE)
+      EXPECT_EQ(CHANNEL_CLOSING, last_filter_event_);
+    last_filter_event_ = FILTER_REMOVED;
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
+    // We should always get the OnFilterAdded and OnChannelConnected events
+    // prior to any messages.
+    EXPECT_EQ(CHANNEL_CONNECTED, last_filter_event_);
+
     if (!is_global_filter_) {
       EXPECT_EQ(supported_message_class_, IPC_MESSAGE_CLASS(message));
     }
     ++messages_received_;
     return message_filtering_enabled_;
   }
 
   virtual bool GetSupportedMessageClasses(
       std::vector<uint32>* supported_message_classes) const OVERRIDE {
     if (is_global_filter_)
       return false;
     supported_message_classes->push_back(supported_message_class_);
     return true;
   }
 
   void set_message_filtering_enabled(bool enabled) {
     message_filtering_enabled_ = enabled;
   }
 
   size_t messages_received() const { return messages_received_; }
-  bool filter_removed() const { return filter_removed_; }
+  FilterEvent last_filter_event() const { return last_filter_event_; }
 
  private:
   virtual ~MessageCountFilter() {}
 
   size_t messages_received_;
   uint32 supported_message_class_;
   bool is_global_filter_;
-  bool filter_removed_;
+
+  FilterEvent last_filter_event_;
   bool message_filtering_enabled_;
 };
 
 class IPCChannelProxyTest : public IPCTestBase {
  public:
   IPCChannelProxyTest() {}
   virtual ~IPCChannelProxyTest() {}
 
   virtual void SetUp() OVERRIDE {
     IPCTestBase::SetUp();
@@ skipping 96 matching lines @@
   channel_proxy()->AddFilter(global_filter.get());
   channel_proxy()->RemoveFilter(global_filter.get());
   channel_proxy()->RemoveFilter(class_filter.get());
 
   // Send some messages; they should not be seen by either filter.
   Send(sender(), 0, SEND);
   Send(sender(), kMessageClass, SEND);
 
   // Ensure that the filters were removed and did not receive any messages.
   SendQuitMessageAndWaitForIdle();
-  EXPECT_TRUE(global_filter->filter_removed());
-  EXPECT_TRUE(class_filter->filter_removed());
+  EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
+            global_filter->last_filter_event());
+  EXPECT_EQ(MessageCountFilter::FILTER_REMOVED,
+            class_filter->last_filter_event());
   EXPECT_EQ(0U, class_filter->messages_received());
   EXPECT_EQ(0U, global_filter->messages_received());
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(ChannelProxyClient) {
   base::MessageLoopForIO main_message_loop;
   ChannelReflectorListener listener;
   IPC::Channel channel(IPCTestBase::GetChannelName("ChannelProxyClient"),
                        IPC::Channel::MODE_CLIENT,
                        &listener);
   CHECK(channel.Connect());
   listener.Init(&channel);
 
   base::MessageLoop::current()->Run();
   return 0;
 }
 
 }  // namespace