Add support in mojo to check if a MojoHandle identifies a message pipe.

mojo/spy/spy.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 "mojo/spy/spy.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 28 matching lines @@
 }
 
 // In charge of processing messages that flow over a
 // single message pipe.
 class MessageProcessor :
     public base::RefCountedThreadSafe<MessageProcessor> {
  public:
   MessageProcessor(base::MessageLoopProxy* control_loop_proxy)
       : last_result_(MOJO_RESULT_OK),
         bytes_transfered_(0),
-        control_loop_proxy_(control_loop_proxy),
-        service_vendor_message_pipe_received_(false) {
+        control_loop_proxy_(control_loop_proxy) {
     message_count_[0] = 0;
     message_count_[1] = 0;
     handle_count_[0] = 0;
     handle_count_[1] = 0;
   }
 
   void Start(mojo::ScopedMessagePipeHandle client,
              mojo::ScopedMessagePipeHandle interceptor,
              const GURL& url) {
     std::vector<mojo::MessagePipeHandle> pipes;
@@ skipping 28 matching lines @@
                                       hbuf.get(), &handles_read,
                                       MOJO_READ_MESSAGE_FLAG_NONE)))
         break;
 
       if (!bytes_read && !handles_read)
         continue;
 
       if (handles_read) {
         handle_count_[r] += handles_read;
 
-        // Intercept the first set of handles to message pipes with the
-        // assumption that these would be used for vending mojo services.
-        // TODO(ananta)
-        // The above approach is hacky and could cause us to miss other message
-        // pipes which could be exchanged between the client and the server.
-        // Look into a cleaner way of identifying message pipe handles.
-        if (!service_vendor_message_pipe_received_) {
-          service_vendor_message_pipe_received_ = true;
-          for (uint32_t i = 0; i < handles_read; i++) {
+        // Intercept message pipes which are returned via the ReadMessageRaw
+        // call
+        for (uint32_t i = 0; i < handles_read; i++) {
+          // Hack to determine if a handle is a message pipe.
+          // TODO(ananta)
+          // We should have an API which given a handle returns its type.
+          if (MojoReadMessage(hbuf[i], NULL, NULL, NULL, NULL,
+                              MOJO_READ_MESSAGE_FLAG_NONE) ==
+                  MOJO_RESULT_RESOURCE_EXHAUSTED) {

[viettrungluu, 2014/07/16 02:40:48]

I believe it'll return MOJO_RESULT_SHOULD_WAIT if no messages are queued.

[ananta, 2014/07/16 21:06:05]

Checked that. It returns MOJO_RESULT_SHOULD_WAIT or
MOJO_RESULT_FAILED_PRECONDITION.

I changed the code to check for MOJO_RESULT_INVALID_ARGUMENT which is what the
default dispatcher returns.

Will work on tests when I get back from vacation the week after next.

             mojo::ScopedMessagePipeHandle message_pipe_handle;
             message_pipe_handle.reset(mojo::MessagePipeHandle(hbuf[i]));
 
             mojo::ScopedMessagePipeHandle faux_client;
             mojo::ScopedMessagePipeHandle interceptor;
             CreateMessagePipe(NULL, &faux_client, &interceptor);
 
             base::WorkerPool::PostTask(
                 FROM_HERE,
                 base::Bind(&MessageProcessor::Start,
@@ skipping 94 matching lines @@
                       base::Unretained(ws_server),
                       message_data->header, url, base::Time::Now()));
     }
   }
 
   MojoResult last_result_;
   uint32_t bytes_transfered_;
   uint32_t message_count_[2];
   uint32_t handle_count_[2];
   scoped_refptr<base::MessageLoopProxy> control_loop_proxy_;
-  // This flag helps us intercept the first message pipe exchanged between
-  // the client and the service vendor.
-  bool service_vendor_message_pipe_received_;
 };
 
 // In charge of intercepting access to the service manager.
 class SpyInterceptor : public mojo::ServiceManager::Interceptor {
  public:
   explicit SpyInterceptor(scoped_refptr<mojo::SpyServerImpl> spy_server,
                           base::MessageLoopProxy* control_loop_proxy)
       : spy_server_(spy_server),
         proxy_(base::MessageLoopProxy::current()),
         control_loop_proxy_(control_loop_proxy){
@@ skipping 96 matching lines @@
   service_manager->SetInterceptor(new SpyInterceptor(
       spy_server_, control_thread_->message_loop_proxy()));
 }
 
 Spy::~Spy() {
   // TODO(cpu): Do not leak the interceptor. Lifetime between the
   // service_manager and the spy is still unclear hence the leak.
 }
 
 }  // namespace mojo