Mojo cpp bindings: add support for validating incoming messages.

mojo/public/cpp/bindings/lib/filter_chain.h

Index: mojo/public/cpp/bindings/lib/filter_chain.h
diff --git a/mojo/public/cpp/bindings/lib/filter_chain.h b/mojo/public/cpp/bindings/lib/filter_chain.h
new file mode 100644
index 0000000000000000000000000000000000000000..df681356f41d1955e1d2e94abbbe4cb51b20762d
--- /dev/null
+++ b/mojo/public/cpp/bindings/lib/filter_chain.h
@@ -0,0 +1,59 @@
+// 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.
+
+#ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_FILTER_CHAIN_H_
+#define MOJO_PUBLIC_CPP_BINDINGS_LIB_FILTER_CHAIN_H_
+
+#include <assert.h>
+
+#include <vector>
+
+#include "mojo/public/cpp/bindings/message.h"
+#include "mojo/public/cpp/bindings/message_filter.h"
+#include "mojo/public/cpp/system/macros.h"
+
+namespace mojo {
+namespace internal {
+
+class FilterChain {
+  MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(FilterChain, RValue)
+
+ public:
+  // Doesn't take ownership of |sink|. Therefore |sink| has to stay alive while
+  // this object is alive.
+  explicit FilterChain(MessageReceiver* sink = NULL);
+
+  // Move-only constructor and operator=.
+  FilterChain(RValue other);
+  FilterChain& operator=(RValue other);
+
+  ~FilterChain();
+
+  // Takes ownership of |filter|.
+  FilterChain& Append(MessageFilter* filter);

[darin (slow to review), 2014/05/15 06:56:02]

Now I understand why you were exploring template method specializations! It
would be nice to not have to heap allocate and then destroy the
PassThroughFilter.

I suppose you could have a global function to help:

  template <typename FilterImpl>
  void Append(FilterChain* chain) {
    chain->Append(new FilterImpl());
  }

  template <>
  void Append<PassThroughFilter>(FilterChain* chain) {
  }

Then, you would write:

  FilterChain chain;
  Append<MessageHeaderValidator>(&chain);
  Append<typename Interface::RequestValidator_>(&chain);
  Append<typename Interface::Client_::ResponseValidator_>(&chain);

Yeah, that doesn't look quite as nice as what you have now.

[yzshen1, 2014/05/15 07:45:31]

Yeah, I experimented with template method specialization and found out that in
order to use Append() in a chain, I need to use the 'template' keyword
explicitly:

chain.Append<XXX>()
     .template Append<YYY>()
     .template Append<ZZZ>();

That seems less nice looking and probably will confuse some users (like me). :/

But there is no need to use 'template' if I break them into three statements:
chain.Append<XXX>();
chain.Append<YYY>();
chain.Append<ZZZ>();

If we want to avoid unnecessary allocation, maybe this last approach is
acceptable?

+  FilterChain& Append(PassThroughFilter* filter);
+
+  // Doesn't take ownership of |sink|. Therefore |sink| has to stay alive while
+  // this object is alive.
+  void set_sink(MessageReceiver* sink) {
+    assert(!sink_);
+    sink_ = sink;
+  }
+
+  // Returns a receiver to accept messages. Messages flow through all filters in
+  // the same order as they were appended to the chain. If all filters allow a
+  // message to pass, it will be forwarded to |sink_|.
+  MessageReceiver* GetHead();
+
+ private:
+  // Owned by this object.
+  std::vector<MessageFilter*> filters_;
+
+  MessageReceiver* sink_;
+};
+
+}  // namespace internal
+}  // namespace mojo
+
+#endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_FILTER_CHAIN_H_