Add a continual_gathering_policy in PeerConnection RTCConfiguration

talk/app/webrtc/peerconnectioninterface.h

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 207 matching lines @@
   enum RtcpMuxPolicy {
     kRtcpMuxPolicyNegotiate,
     kRtcpMuxPolicyRequire,
   };
 
   enum TcpCandidatePolicy {
     kTcpCandidatePolicyEnabled,
     kTcpCandidatePolicyDisabled
   };
 
+  enum ContinuousGatheringPolicy {

[pthatcher1, 2015/09/25 22:26:57]

Based on http://blog.dictionary.com/continually-vs-continuously/, this should
really be called ContinualGatheringPolicy

[honghaiz3, 2015/09/25 23:05:00]

Done.

+    kGatheringOnce,
+    kGatheringContinuously

[pthatcher1, 2015/09/25 22:26:57]

Cand kGatherContinually

[pthatcher1, 2015/09/25 22:26:57]

The new enum style is GATHERING_CONTINUALLY.

[pthatcher1, 2015/09/25 22:26:57]

kGatherOnce
kGatherContinuosly

[honghaiz3, 2015/09/25 23:05:00]

Done.

[honghaiz3, 2015/09/25 23:05:00]

Done.

[honghaiz3, 2015/09/25 23:05:00]

Done.

+  };
+
   // TODO(hbos): Change into class with private data and public getters.
   struct RTCConfiguration {
     static const int kUndefined = -1;
     // Default maximum number of packets in the audio jitter buffer.
     static const int kAudioJitterBufferMaxPackets = 50;
     // TODO(pthatcher): Rename this ice_transport_type, but update
     // Chromium at the same time.
     IceTransportsType type;
     // TODO(pthatcher): Rename this ice_servers, but update Chromium
     // at the same time.
     IceServers servers;
     // A localhost candidate is signaled whenever a candidate with the any
     // address is allocated.
     bool enable_localhost_ice_candidate;
     BundlePolicy bundle_policy;
     RtcpMuxPolicy rtcp_mux_policy;
     TcpCandidatePolicy tcp_candidate_policy;
     int audio_jitter_buffer_max_packets;
     bool audio_jitter_buffer_fast_accelerate;
     int ice_connection_receiving_timeout;
+    ContinuousGatheringPolicy continuous_gathering_policy;
     std::vector<rtc::scoped_refptr<rtc::RTCCertificate>> certificates;
 
     RTCConfiguration()
         : type(kAll),
           enable_localhost_ice_candidate(false),
           bundle_policy(kBundlePolicyBalanced),
           rtcp_mux_policy(kRtcpMuxPolicyNegotiate),
           tcp_candidate_policy(kTcpCandidatePolicyEnabled),
           audio_jitter_buffer_max_packets(kAudioJitterBufferMaxPackets),
           audio_jitter_buffer_fast_accelerate(false),
-          ice_connection_receiving_timeout(kUndefined) {}
+          ice_connection_receiving_timeout(kUndefined),
+          continuous_gathering_policy(kGatheringOnce) {}
   };
 
   struct RTCOfferAnswerOptions {
     static const int kUndefined = -1;
     static const int kMaxOfferToReceiveMedia = 1;
 
     // The default value for constraint offerToReceiveX:true.
     static const int kOfferToReceiveMediaTrue = 1;
 
     int offer_to_receive_video;
@@ skipping 329 matching lines @@
 CreatePeerConnectionFactory(
     rtc::Thread* worker_thread,
     rtc::Thread* signaling_thread,
     AudioDeviceModule* default_adm,
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory);
 
 }  // namespace webrtc
 
 #endif  // TALK_APP_WEBRTC_PEERCONNECTIONINTERFACE_H_