CallSetupStateTracker and unittests added.

This helper class keeps track of an offerer state and an answerer state
and makes sure that the transitions between different states are valid.
By having a single state that reports whether the call setup was
successful or if (and in which step) it failed we can be sure to get
trustworthy comparisons between % success and % failures, which is
important for the Unified Plan experiments.

Follow-up CL(s) will wire up RTCPeerConnection to use this helper class
and make sure the states are reported with UMA.

Bug: 906029
Change-Id: Iafb77533c66c7625269e3c6e33ef954d88e54cdb
Reviewed-on: https://chromium-review.googlesource.com/c/1340299Reviewed-by: Philip Jägenstedt <foolip@chromium.org>
Reviewed-by: Harald Alvestrand <hta@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Commit-Queue: Henrik Boström <hbos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#609685}

third_party/blink/renderer/modules/BUILD.gn

@@ -318,6 +318,7 @@ jumbo_source_set("unit_tests") {
     "peerconnection/adapters/p2p_quic_stream_unittest.cc",
     "peerconnection/adapters/p2p_quic_transport_test.cc",
     "peerconnection/byte_buffer_queue_test.cc",
+    "peerconnection/call_setup_state_tracker_unittest.cc",
     "peerconnection/rtc_data_channel_test.cc",
     "peerconnection/rtc_ice_transport_test.cc",
     "peerconnection/rtc_ice_transport_test.h",

third_party/blink/renderer/modules/peerconnection/BUILD.gn

@@ -36,6 +36,8 @@ blink_modules_sources("peerconnection") {
     "adapters/web_rtc_cross_thread_copier.h",
     "byte_buffer_queue.cc",
     "byte_buffer_queue.h",
+    "call_setup_state_tracker.cc",
+    "call_setup_state_tracker.h",
     "rtc_certificate.cc",
     "rtc_certificate.h",
     "rtc_data_channel.cc",

third_party/blink/renderer/modules/peerconnection/call_setup_state_tracker.cc

+// Copyright (c) 2018 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 "third_party/blink/renderer/modules/peerconnection/call_setup_state_tracker.h"
+
+namespace blink {
+
+CallSetupStateTracker::CallSetupStateTracker()
+    : valid_offerer_transitions_(
+          {std::make_pair(OffererState::kNotStarted,
+                          OffererState::kCreateOfferPending),
+           // createOffer()
+           std::make_pair(OffererState::kCreateOfferPending,
+                          OffererState::kCreateOfferRejected),
+           std::make_pair(OffererState::kCreateOfferPending,
+                          OffererState::kCreateOfferResolved),
+           std::make_pair(OffererState::kCreateOfferRejected,
+                          OffererState::kCreateOfferResolved),
+           std::make_pair(OffererState::kCreateOfferResolved,
+                          OffererState::kSetLocalOfferPending),
+           // setLocalDescription(offer)
+           std::make_pair(OffererState::kSetLocalOfferPending,
+                          OffererState::kSetLocalOfferRejected),
+           std::make_pair(OffererState::kSetLocalOfferPending,
+                          OffererState::kSetLocalOfferResolved),
+           std::make_pair(OffererState::kSetLocalOfferRejected,
+                          OffererState::kSetLocalOfferResolved),
+           std::make_pair(OffererState::kSetLocalOfferResolved,
+                          OffererState::kSetRemoteAnswerPending),
+           // setRemoteDescription(answer)
+           std::make_pair(OffererState::kSetRemoteAnswerPending,
+                          OffererState::kSetRemoteAnswerRejected),
+           std::make_pair(OffererState::kSetRemoteAnswerPending,
+                          OffererState::kSetRemoteAnswerResolved),
+           std::make_pair(OffererState::kSetRemoteAnswerRejected,
+                          OffererState::kSetRemoteAnswerResolved)}),
+      valid_answerer_transitions_({
+          std::make_pair(AnswererState::kNotStarted,
+                         AnswererState::kSetRemoteOfferPending),
+          // setRemoteDescription(answer)
+          std::make_pair(AnswererState::kSetRemoteOfferPending,
+                         AnswererState::kSetRemoteOfferRejected),
+          std::make_pair(AnswererState::kSetRemoteOfferPending,
+                         AnswererState::kSetRemoteOfferResolved),
+          std::make_pair(AnswererState::kSetRemoteOfferRejected,
+                         AnswererState::kSetRemoteOfferResolved),
+          std::make_pair(AnswererState::kSetRemoteOfferResolved,
+                         AnswererState::kCreateAnswerPending),
+          // createAnswer()
+          std::make_pair(AnswererState::kCreateAnswerPending,
+                         AnswererState::kCreateAnswerRejected),
+          std::make_pair(AnswererState::kCreateAnswerPending,
+                         AnswererState::kCreateAnswerResolved),
+          std::make_pair(AnswererState::kCreateAnswerRejected,
+                         AnswererState::kCreateAnswerResolved),
+          std::make_pair(AnswererState::kCreateAnswerResolved,
+                         AnswererState::kSetLocalAnswerPending),
+          // setLocalDescription(answer)
+          std::make_pair(AnswererState::kSetLocalAnswerPending,
+                         AnswererState::kSetLocalAnswerRejected),
+          std::make_pair(AnswererState::kSetLocalAnswerPending,
+                         AnswererState::kSetLocalAnswerResolved),
+          std::make_pair(AnswererState::kSetLocalAnswerRejected,
+                         AnswererState::kSetLocalAnswerResolved),
+      }),
+      offerer_state_(OffererState::kNotStarted),
+      answerer_state_(AnswererState::kNotStarted) {}
+
+OffererState CallSetupStateTracker::offerer_state() const {
+  return offerer_state_;
+}
+
+AnswererState CallSetupStateTracker::answerer_state() const {
+  return answerer_state_;
+}
+
+bool CallSetupStateTracker::NoteOffererStateEvent(OffererState event) {
+  auto transition = std::make_pair(offerer_state_, event);
+  if (valid_offerer_transitions_.find(transition) ==
+      valid_offerer_transitions_.end()) {
+    return false;
+  }
+  offerer_state_ = event;
+  return true;
+}
+
+bool CallSetupStateTracker::NoteAnswererStateEvent(AnswererState event) {
+  auto transition = std::make_pair(answerer_state_, event);
+  if (valid_answerer_transitions_.find(transition) ==
+      valid_answerer_transitions_.end()) {
+    return false;
+  }
+  answerer_state_ = event;
+  return true;
+}
+
+}  // namespace blink

third_party/blink/renderer/modules/peerconnection/call_setup_state_tracker.h

+// Copyright (c) 2018 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 THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_CALL_SETUP_STATE_TRACKER_H_
+#define THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_CALL_SETUP_STATE_TRACKER_H_
+
+#include <set>
+#include <utility>
+
+#include "third_party/blink/renderer/modules/modules_export.h"
+
+namespace blink {
+
+// Represents the different states that an offerer can go through during call
+// setup, where later steps involve SDP exchange.
+//
+// Valid transitions are from an operation's "pending" to "resolved" or
+// "rejected" state. "Rejected" can transition to "resolved" if another attempt
+// is made (without going to "pending" in-between). Only "resolved" can
+// transition to the next operation's "pending" state. Transition between
+// operations are only valid in the defined order.
+//
+// The model we are using is one that measures how close we get to establishing
+// a connection. In reality, the peer connection may make multiple tries, and
+// follow multiple paths towards reaching a connected state, but we're only
+// interested in seeing how far it got on its most successful attempt.
+enum class OffererState {
+  kNotStarted = 0,
+  // createOffer()
+  kCreateOfferPending = 1,
+  kCreateOfferRejected = 2,
+  kCreateOfferResolved = 3,
+  // setLocalDescription(offer)
+  kSetLocalOfferPending = 4,
+  kSetLocalOfferRejected = 5,
+  kSetLocalOfferResolved = 6,
+  // setRemoteDescription(answer)
+  kSetRemoteAnswerPending = 7,
+  kSetRemoteAnswerRejected = 8,
+  kSetRemoteAnswerResolved = 9,
+
+  kMaxValue = kSetRemoteAnswerResolved,
+};
+
+// Represents the different states that an answerer can go through during call
+// setup, where initial steps involve SDP exchange. The transition graph for
+// this enum follows the same logic as OffererState, see above.
+enum class AnswererState {
+  kNotStarted = 0,
+  // setRemoteDescription(offer)
+  kSetRemoteOfferPending = 1,
+  kSetRemoteOfferRejected = 2,
+  kSetRemoteOfferResolved = 3,
+  // createAnswer()
+  kCreateAnswerPending = 4,
+  kCreateAnswerRejected = 5,
+  kCreateAnswerResolved = 6,
+  // setLocalDescription(answer)
+  kSetLocalAnswerPending = 7,
+  kSetLocalAnswerRejected = 8,
+  kSetLocalAnswerResolved = 9,
+
+  kMaxValue = kSetLocalAnswerResolved,
+};
+
+class MODULES_EXPORT CallSetupStateTracker {
+ public:
+  CallSetupStateTracker();
+
+  OffererState offerer_state() const;
+  AnswererState answerer_state() const;
+
+  bool NoteOffererStateEvent(OffererState event);
+  bool NoteAnswererStateEvent(AnswererState event);
+
+ private:
+  const std::set<std::pair<OffererState, OffererState>>
+      valid_offerer_transitions_;
+  const std::set<std::pair<AnswererState, AnswererState>>
+      valid_answerer_transitions_;
+
+  OffererState offerer_state_;
+  AnswererState answerer_state_;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_PEERCONNECTION_CALL_SETUP_STATE_TRACKER_H_