Fix ASSERT in JingleMessage::OrderedMessageQueue.

remoting/protocol/jingle_session.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/jingle_session.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
@@ skipping 97 matching lines @@
 class JingleSession::OrderedMessageQueue {
  public:
   OrderedMessageQueue() {}
   ~OrderedMessageQueue() {}
 
   // Returns the list of messages ordered by their sequential IDs.
   std::vector<PendingMessage> OnIncomingMessage(
       const std::string& id,
       PendingMessage&& pending_message);
 
+  // Sets the initial ID of the session initiate message.
+  void SetInitialId(const std::string& id);
+
  private:
   // Implements an ordered list by using map with the |sequence_id| as the key,
   // so that |queue_| is always sorted by |sequence_id|.
   std::map<int, PendingMessage> queue_;
 
   int next_incoming_ = kAny;
 
   DISALLOW_COPY_AND_ASSIGN(OrderedMessageQueue);
 };
 
@@ skipping 27 matching lines @@
     next_incoming_++;
   }
 
   if (current - next_incoming_ >= 3) {
     LOG(WARNING) << "Multiple messages are missing: expected= "
                  << next_incoming_ << " current= " << current;
   }
   return result;
 };
 
+void JingleSession::OrderedMessageQueue::SetInitialId(const std::string& id) {
+  int current = GetSequentialId(id);
+  if (current != kInvalid)
+    next_incoming_ = current + 1;
+}
+
 JingleSession::PendingMessage::PendingMessage() = default;
 JingleSession::PendingMessage::PendingMessage(PendingMessage&& moved) = default;
 JingleSession::PendingMessage::PendingMessage(
     std::unique_ptr<JingleMessage> message,
     const ReplyCallback& reply_callback)
     : message(std::move(message)), reply_callback(reply_callback) {}
 JingleSession::PendingMessage::~PendingMessage() = default;
 
 JingleSession::PendingMessage& JingleSession::PendingMessage::operator=(
     PendingMessage&& moved) = default;
@@ skipping 42 matching lines @@
   // Delay sending session-initiate message to ensure SessionPlugin can be
   // attached before the message.
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
       base::Bind(&JingleSession::SendSessionInitiateMessage,
                  weak_factory_.GetWeakPtr()));
 
   SetState(CONNECTING);
 }
 
 void JingleSession::InitializeIncomingConnection(
+    const std::string& message_id,
     const JingleMessage& initiate_message,
     std::unique_ptr<Authenticator> authenticator) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initiate_message.description.get());
   DCHECK(authenticator.get());
   DCHECK_EQ(authenticator->state(), Authenticator::WAITING_MESSAGE);
 
   peer_address_ = initiate_message.from;
   authenticator_ = std::move(authenticator);
   session_id_ = initiate_message.sid;
+  message_queue_->SetInitialId(message_id);
 
   SetState(ACCEPTING);
 
   config_ =
       SessionConfig::SelectCommon(initiate_message.description->config(),
                                   session_manager_->protocol_config_.get());
   if (!config_) {
     LOG(WARNING) << "Rejecting connection from " << peer_address_.id()
                  << " because no compatible configuration has been found.";
     Close(INCOMPATIBLE_PROTOCOL);
@@ skipping 553 matching lines @@
       authenticator_->GetNextMessage()));
   SendMessage(std::move(message));
 }
 
 std::string JingleSession::GetNextOutgoingId() {
   return outgoing_id_prefix_ + "_" + base::IntToString(++next_outgoing_id_);
 }
 
 }  // namespace protocol
 }  // namespace remoting