Mojo Spy: Fix a couple of bugs noticed by vtl@ and qsr@

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 "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/threading/worker_pool.h"
 
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/service_manager/service_manager.h"
 
 namespace {
 
 const size_t kMessageBufSize = 2 * 1024;
 const size_t kHandleBufSize = 64;
 
+void CloseHandles(MojoHandle* handles, size_t count) {
+  for (size_t ix = 0; ix != count; ++count)
+    MojoClose(handles[ix]);
+}
+
 // In charge of processing messages that flow over a
 // single message pipe.
 class MessageProcessor :
     public base::RefCountedThreadSafe<MessageProcessor> {
  public:
 
   MessageProcessor()
       : last_result_(MOJO_RESULT_OK),
         bytes_transfered_(0) {
 
     message_count_[0] = 0;
     message_count_[1] = 0;
     handle_count_[0] = 0;
     handle_count_[1] = 0;
   }
 
   void Start(mojo::ScopedMessagePipeHandle client,
              mojo::ScopedMessagePipeHandle interceptor) {
     std::vector<mojo::MessagePipeHandle> pipes;
     pipes.push_back(client.get());
     pipes.push_back(interceptor.get());
     std::vector<MojoWaitFlags> wait_flags;
     wait_flags.push_back(MOJO_WAIT_FLAG_READABLE);
     wait_flags.push_back(MOJO_WAIT_FLAG_READABLE);
 
-    scoped_ptr<char> mbuf(new char[kMessageBufSize]);
-    scoped_ptr<MojoHandle> hbuf(new MojoHandle[kHandleBufSize]);
+    scoped_ptr<char[]> mbuf(new char[kMessageBufSize]);
+    scoped_ptr<MojoHandle[]> hbuf(new MojoHandle[kHandleBufSize]);
 
     // Main processing loop:
     // 1- Wait for an endpoint to have a message.
     // 2- Read the message
     // 3- Log data
     // 4- Wait until the opposite port is ready for writting
     // 4- Write the message to opposite port.
 
     for (;;) {
       int r = WaitMany(pipes, wait_flags, MOJO_DEADLINE_INDEFINITE);
@@ skipping 22 matching lines @@
 
       mojo::MessagePipeHandle write_handle = (r == 0) ? pipes[1] : pipes[0];
       if (!CheckResult(Wait(write_handle,
                             MOJO_WAIT_FLAG_WRITABLE,
                             MOJO_DEADLINE_INDEFINITE)))
         break;
 
       if (!CheckResult(WriteMessageRaw(write_handle,
                                        mbuf.get(), bytes_read,
                                        hbuf.get(), handles_read,
-                                       MOJO_WRITE_MESSAGE_FLAG_NONE)))
+                                       MOJO_WRITE_MESSAGE_FLAG_NONE))) {
+        // On failure we own the handles. For now just close them.
+        if (handles_read)
+          CloseHandles(hbuf.get(), handles_read);
         break;
+      }
     }
-
   }
 
  private:
    friend class base::RefCountedThreadSafe<MessageProcessor>;
    virtual ~MessageProcessor() {}
 
    bool CheckResult(MojoResult mr) {
      if (mr == MOJO_RESULT_OK)
        return true;
      last_result_ = mr;
@@ skipping 47 matching lines @@
 Spy::Spy(mojo::ServiceManager* service_manager, const std::string& options) {
   service_manager->SetInterceptor(new SpyInterceptor());
 }
 
 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