Remove done notifications from incoming message handlers.

remoting/protocol/channel_multiplexer.cc

 // Copyright (c) 2012 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 "remoting/protocol/channel_multiplexer.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 12 matching lines @@
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 const int kChannelIdUnknown = -1;
 const int kMaxPacketSize = 1024;
 
 class PendingPacket {
  public:
-  PendingPacket(scoped_ptr<MultiplexPacket> packet,
-                const base::Closure& done_task)
-      : packet(std::move(packet)),
-        done_task(done_task),
-        pos(0U) {
-  }
-  ~PendingPacket() {
-    done_task.Run();
-  }
+  PendingPacket(scoped_ptr<MultiplexPacket> packet)
+      : packet(std::move(packet)) {}
+  ~PendingPacket() {}
 
   bool is_empty() { return pos >= packet->data().size(); }
 
   int Read(char* buffer, size_t size) {
     size = std::min(size, packet->data().size() - pos);
     memcpy(buffer, packet->data().data() + pos, size);
     pos += size;
     return size;
   }
 
  private:
   scoped_ptr<MultiplexPacket> packet;
-  base::Closure done_task;
-  size_t pos;
+  size_t pos = 0U;
 
   DISALLOW_COPY_AND_ASSIGN(PendingPacket);
 };
 
 }  // namespace
 
 const char ChannelMultiplexer::kMuxChannelName[] = "mux";
 
 struct ChannelMultiplexer::PendingChannel {
   PendingChannel(const std::string& name,
                  const ChannelCreatedCallback& callback)
       : name(name), callback(callback) {
   }
   std::string name;
   ChannelCreatedCallback callback;
 };
 
 class ChannelMultiplexer::MuxChannel {
  public:
   MuxChannel(ChannelMultiplexer* multiplexer, const std::string& name,
              int send_id);
   ~MuxChannel();
 
   const std::string& name() { return name_; }
   int receive_id() { return receive_id_; }
   void set_receive_id(int id) { receive_id_ = id; }
 
   // Called by ChannelMultiplexer.
   scoped_ptr<P2PStreamSocket> CreateSocket();
-  void OnIncomingPacket(scoped_ptr<MultiplexPacket> packet,
-                        const base::Closure& done_task);
+  void OnIncomingPacket(scoped_ptr<MultiplexPacket> packet);
   void OnBaseChannelError(int error);
 
   // Called by MuxSocket.
   void OnSocketDestroyed();
   void DoWrite(scoped_ptr<MultiplexPacket> packet,
                const base::Closure& done_task);
   int DoRead(const scoped_refptr<net::IOBuffer>& buffer, int buffer_len);
 
  private:
   ChannelMultiplexer* multiplexer_;
@@ skipping 60 matching lines @@
 }
 
 scoped_ptr<P2PStreamSocket> ChannelMultiplexer::MuxChannel::CreateSocket() {
   DCHECK(!socket_);  // Can't create more than one socket per channel.
   scoped_ptr<MuxSocket> result(new MuxSocket(this));
   socket_ = result.get();
   return std::move(result);
 }
 
 void ChannelMultiplexer::MuxChannel::OnIncomingPacket(
-    scoped_ptr<MultiplexPacket> packet,
-    const base::Closure& done_task) {
+    scoped_ptr<MultiplexPacket> packet) {
   DCHECK_EQ(packet->channel_id(), receive_id_);
   if (packet->data().size() > 0) {
-    pending_packets_.push_back(new PendingPacket(std::move(packet), done_task));
+    pending_packets_.push_back(new PendingPacket(std::move(packet)));
     if (socket_) {
       // Notify the socket that we have more data.
       socket_->OnPacketReceived();
     }
   }
 }
 
 void ChannelMultiplexer::MuxChannel::OnBaseChannelError(int error) {
   if (socket_)
     socket_->OnBaseChannelError(error);
@@ skipping 244 matching lines @@
   }
 }
 
 void ChannelMultiplexer::NotifyBaseChannelError(const std::string& name,
                                                 int error) {
   std::map<std::string, MuxChannel*>::iterator it = channels_.find(name);
   if (it != channels_.end())
     it->second->OnBaseChannelError(error);
 }
 
-void ChannelMultiplexer::OnIncomingPacket(scoped_ptr<MultiplexPacket> packet,
-                                          const base::Closure& done_task) {
+void ChannelMultiplexer::OnIncomingPacket(scoped_ptr<MultiplexPacket> packet) {
   DCHECK(packet->has_channel_id());
   if (!packet->has_channel_id()) {
     LOG(ERROR) << "Received packet without channel_id.";
-    done_task.Run();
     return;
   }
 
   int receive_id = packet->channel_id();
   MuxChannel* channel = nullptr;
   std::map<int, MuxChannel*>::iterator it =
       channels_by_receive_id_.find(receive_id);
   if (it != channels_by_receive_id_.end()) {
     channel = it->second;
   } else {
     // This is a new |channel_id| we haven't seen before. Look it up by name.
     if (!packet->has_channel_name()) {
       LOG(ERROR) << "Received packet with unknown channel_id and "
           "without channel_name.";
-      done_task.Run();
       return;
     }
     channel = GetOrCreateChannel(packet->channel_name());
     channel->set_receive_id(receive_id);
     channels_by_receive_id_[receive_id] = channel;
   }
 
-  channel->OnIncomingPacket(std::move(packet), done_task);
+  channel->OnIncomingPacket(std::move(packet));
 }
 
 void ChannelMultiplexer::DoWrite(scoped_ptr<MultiplexPacket> packet,
                                  const base::Closure& done_task) {
   writer_.Write(SerializeAndFrameMessage(*packet), done_task);
 }
 
 }  // namespace protocol
 }  // namespace remoting