WebRTCStatsMember: Support for bool and sequence of bool

content/renderer/media/rtc_peer_connection_handler_unittest.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 "content/renderer/media/rtc_peer_connection_handler.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 662 matching lines @@
 
 TEST_F(RTCPeerConnectionHandlerTest, GetRTCStats) {
   rtc::scoped_refptr<webrtc::RTCStatsReport> report =
       webrtc::RTCStatsReport::Create();
 
   report->AddStats(std::unique_ptr<const webrtc::RTCStats>(
       new webrtc::RTCTestStats("RTCUndefinedStats", 1000)));
 
   std::unique_ptr<webrtc::RTCTestStats> stats_defined_members(
       new webrtc::RTCTestStats("RTCDefinedStats", 2000));
+  stats_defined_members->m_bool = true;
   stats_defined_members->m_int32 = 42;
   stats_defined_members->m_uint32 = 42;
   stats_defined_members->m_int64 = 42;
   stats_defined_members->m_uint64 = 42;
   stats_defined_members->m_double = 42.0;
   stats_defined_members->m_string = "42";
+  stats_defined_members->m_sequence_bool = ToSequence<bool>(true);
   stats_defined_members->m_sequence_int32 = ToSequence<int32_t>(42);
   stats_defined_members->m_sequence_uint32 = ToSequence<uint32_t>(42);
   stats_defined_members->m_sequence_int64 = ToSequence<int64_t>(42);
   stats_defined_members->m_sequence_uint64 = ToSequence<uint64_t>(42);
   stats_defined_members->m_sequence_double = ToSequence<double>(42);
   stats_defined_members->m_sequence_string = ToSequence<std::string>("42");
   report->AddStats(std::unique_ptr<const webrtc::RTCStats>(
       stats_defined_members.release()));
 
   pc_handler_->native_peer_connection()->SetGetStatsReport(report);
@@ skipping 23 matching lines @@
             stats->getMember(i);
         // TODO(hbos): A WebRTC-change is adding new members, this would cause
         // not all members to be defined. This if-statement saves Chromium from
         // crashing. As soon as the change has been rolled in, I will update
         // this test. crbug.com/627816
         if (!member->isDefined())
           continue;
         EXPECT_TRUE(member->isDefined());
         members.insert(member->type());
         switch (member->type()) {
+          case blink::WebRTCStatsMemberTypeBool:
+            EXPECT_EQ(member->valueBool(), true);
+            break;
           case blink::WebRTCStatsMemberTypeInt32:
             EXPECT_EQ(member->valueInt32(), static_cast<int32_t>(42));
             break;
           case blink::WebRTCStatsMemberTypeUint32:
             EXPECT_EQ(member->valueUint32(), static_cast<uint32_t>(42));
             break;
           case blink::WebRTCStatsMemberTypeInt64:
             EXPECT_EQ(member->valueInt64(), static_cast<int64_t>(42));
             break;
           case blink::WebRTCStatsMemberTypeUint64:
             EXPECT_EQ(member->valueUint64(), static_cast<uint64_t>(42));
             break;
           case blink::WebRTCStatsMemberTypeDouble:
             EXPECT_EQ(member->valueDouble(), 42.0);
             break;
           case blink::WebRTCStatsMemberTypeString:
             EXPECT_EQ(member->valueString(), blink::WebString::fromUTF8("42"));
             break;
+          case blink::WebRTCStatsMemberTypeSequenceBool:
+            ExpectSequenceEquals(member->valueSequenceBool(), 1);
+            break;
           case blink::WebRTCStatsMemberTypeSequenceInt32:
             ExpectSequenceEquals(member->valueSequenceInt32(),
                                  static_cast<int32_t>(42));
             break;
           case blink::WebRTCStatsMemberTypeSequenceUint32:
             ExpectSequenceEquals(member->valueSequenceUint32(),
                                  static_cast<uint32_t>(42));
             break;
           case blink::WebRTCStatsMemberTypeSequenceInt64:
             ExpectSequenceEquals(member->valueSequenceInt64(),
                                  static_cast<int64_t>(42));
             break;
           case blink::WebRTCStatsMemberTypeSequenceUint64:
             ExpectSequenceEquals(member->valueSequenceUint64(),
                                  static_cast<uint64_t>(42));
             break;
           case blink::WebRTCStatsMemberTypeSequenceDouble:
             ExpectSequenceEquals(member->valueSequenceDouble(), 42.0);
             break;
           case blink::WebRTCStatsMemberTypeSequenceString:
             ExpectSequenceEquals(member->valueSequenceString(),
                                  blink::WebString::fromUTF8("42"));
             break;
           default:
             NOTREACHED();
         }
       }
-      EXPECT_EQ(members.size(), static_cast<size_t>(12));
+      EXPECT_EQ(members.size(), static_cast<size_t>(14));
     } else {
       NOTREACHED();
     }
   }
   EXPECT_EQ(undefined_stats_count, 1);
   EXPECT_EQ(defined_stats_count, 1);
 }
 
 TEST_F(RTCPeerConnectionHandlerTest, OnSignalingChange) {
   testing::InSequence sequence;
@@ skipping 417 matching lines @@
                                     testing::Ref(tracks[0])));
 
   std::unique_ptr<blink::WebRTCDTMFSenderHandler> sender(
       pc_handler_->createDTMFSender(tracks[0]));
   EXPECT_TRUE(sender.get());
 
   StopAllTracks(local_stream);
 }
 
 }  // namespace content