Ticket #19569: 0001-DataChannel-only-libwebrtc.patch

File 0001-DataChannel-only-libwebrtc.patch, 48.7 KB (added by arlolra, 3 years ago)
  • gitian/descriptors/linux/gitian-pluggable-transports.yml

    From d499d99793e2227a313b4ddc2f59f85967d33075 Mon Sep 17 00:00:00 2001
    From: Arlo Breault <arlolra@gmail.com>
    Date: Fri, 12 Aug 2016 19:49:56 -0700
    Subject: [PATCH] DataChannel-only libwebrtc
    
     * trac 19569
    ---
     .../linux/gitian-pluggable-transports.yml          |    9 +-
     gitian/patches/0001-With-a-rat-fur.patch           | 1283 ++++++++++++++++++++
     gitian/versions                                    |    2 +-
     gitian/versions.alpha                              |    2 +-
     gitian/versions.beta                               |    2 +-
     5 files changed, 1289 insertions(+), 9 deletions(-)
     create mode 100644 gitian/patches/0001-With-a-rat-fur.patch
    
    diff --git a/gitian/descriptors/linux/gitian-pluggable-transports.yml b/gitian/descriptors/linux/gitian-pluggable-transports.yml
    index e162229..9e29255 100644
    a b files: 
    7373- "gcc-linux32-utils.zip"
    7474- "gcc-linux64-utils.zip"
    7575- "webrtc"
     76- "0001-With-a-rat-fur.patch"
    7677script: |
    7778  INSTDIR="$HOME/install"
    7879  PTDIR="$INSTDIR/Tor/PluggableTransports"
    script: | 
    326327
    327328  # Building webrtc
    328329  cd webrtc/src
     330  git am ~/build/0001-With-a-rat-fur.patch
    329331  export GYP_CROSSCOMPILE=1
    330332  export GYP_DEFINES="OS=linux target_arch=$(if [ $GBUILD_BITS = 32 ]; then echo ia32; else echo x64; fi)"
    331333  # Do not use bundled utilities.
    script: | 
    340342  # https://bugs.chromium.org/p/chromium/issues/detail?id=318413.
    341343  GYP_DEFINES+=" embedded=1"
    342344  GYP_DEFINES+=" werror="
    343   JAVA_HOME=/usr/lib/jvm/default-java webrtc/build/gyp_webrtc.py
     345  JAVA_HOME=/usr/lib/jvm/default-java webrtc/build/gyp_webrtc.py webrtc/api/api.gyp
    344346  ninja -C out/Release
    345   # Run ninja once more, without include_tests=0, in order to build just the
    346   # FakeAudioCaptureModule that go-webrtc uses.
    347   GYP_DEFINES="$(echo "$GYP_DEFINES" | sed -e 's/include_tests=0//g')"
    348   JAVA_HOME=/usr/lib/jvm/default-java webrtc/build/gyp_webrtc.py
    349   ninja -C out/Release peerconnection_unittests.isolated
    350347  # https://github.com/keroserene/go-webrtc/issues/23#issuecomment-175312648
    351348  # dump_syms_regtest.o is actually an executable, not an object file. If not
    352349  # excluded, it results in the error:
  • new file gitian/patches/0001-With-a-rat-fur.patch

    diff --git a/gitian/patches/0001-With-a-rat-fur.patch b/gitian/patches/0001-With-a-rat-fur.patch
    new file mode 100644
    index 0000000..7d37c9f
    - +  
     1From baef69058c64651cd6d5a3d81cce6a9fa5b5c937 Mon Sep 17 00:00:00 2001
     2From: Arlo Breault <arlolra@gmail.com>
     3Date: Fri, 1 Jul 2016 19:07:47 -0700
     4Subject: [PATCH] With a rat fur
     5
     6---
     7 webrtc/api/api.gyp                      | 365 +++++++++++++++++++++-----------
     8 webrtc/api/mediacontroller.cc           |   6 +
     9 webrtc/api/peerconnection.cc            |  58 ++++-
     10 webrtc/api/peerconnection.h             |  14 +-
     11 webrtc/api/peerconnectionfactory.cc     |  20 +-
     12 webrtc/api/peerconnectionfactory.h      |  11 +-
     13 webrtc/api/peerconnectionfactoryproxy.h |   6 +
     14 webrtc/api/peerconnectioninterface.h    |   8 +
     15 webrtc/api/peerconnectionproxy.h        |   6 +
     16 webrtc/api/statscollector.cc            |   4 +
     17 webrtc/build/common.gypi                |   1 +
     18 webrtc/call.h                           |   4 +
     19 webrtc/call/call.cc                     |  39 ++++
     20 webrtc/call/webrtc_call.gypi            |   8 +-
     21 webrtc/media/media.gyp                  |  73 ++++++-
     22 webrtc/pc/channelmanager.cc             |   6 +
     23 webrtc/pc/mediasession.cc               |   2 +
     24 webrtc/pc/pc.gyp                        |   2 +-
     25 webrtc/webrtc.gyp                       |   2 +-
     26 19 files changed, 488 insertions(+), 147 deletions(-)
     27
     28diff --git a/webrtc/api/api.gyp b/webrtc/api/api.gyp
     29index 377ef8f..2483600 100644
     30--- a/webrtc/api/api.gyp
     31+++ b/webrtc/api/api.gyp
     32@@ -121,138 +121,253 @@
     33         }, # libjingle_peerconnection_java
     34       ]
     35     }],
     36-  ],  # conditions
     37-  'targets': [
     38-    {
     39-      'target_name': 'libjingle_peerconnection',
     40-      'type': 'static_library',
     41-      'dependencies': [
     42-        '<(webrtc_root)/media/media.gyp:rtc_media',
     43-        '<(webrtc_root)/pc/pc.gyp:rtc_pc',
     44-      ],
     45-      'sources': [
     46-        'audiotrack.cc',
     47-        'audiotrack.h',
     48-        'datachannel.cc',
     49-        'datachannel.h',
     50-        'datachannelinterface.h',
     51-        'dtlsidentitystore.cc',
     52-        'dtlsidentitystore.h',
     53-        'dtmfsender.cc',
     54-        'dtmfsender.h',
     55-        'dtmfsenderinterface.h',
     56-        'jsep.h',
     57-        'jsepicecandidate.cc',
     58-        'jsepicecandidate.h',
     59-        'jsepsessiondescription.cc',
     60-        'jsepsessiondescription.h',
     61-        'localaudiosource.cc',
     62-        'localaudiosource.h',
     63-        'mediaconstraintsinterface.cc',
     64-        'mediaconstraintsinterface.h',
     65-        'mediacontroller.cc',
     66-        'mediacontroller.h',
     67-        'mediastream.cc',
     68-        'mediastream.h',
     69-        'mediastreaminterface.h',
     70-        'mediastreamobserver.cc',
     71-        'mediastreamobserver.h',
     72-        'mediastreamprovider.h',
     73-        'mediastreamproxy.h',
     74-        'mediastreamtrack.h',
     75-        'mediastreamtrackproxy.h',
     76-        'notifier.h',
     77-        'peerconnection.cc',
     78-        'peerconnection.h',
     79-        'peerconnectionfactory.cc',
     80-        'peerconnectionfactory.h',
     81-        'peerconnectionfactoryproxy.h',
     82-        'peerconnectioninterface.h',
     83-        'peerconnectionproxy.h',
     84-        'proxy.h',
     85-        'remoteaudiosource.cc',
     86-        'remoteaudiosource.h',
     87-        'rtpparameters.h',
     88-        'rtpreceiver.cc',
     89-        'rtpreceiver.h',
     90-        'rtpreceiverinterface.h',
     91-        'rtpsender.cc',
     92-        'rtpsender.h',
     93-        'rtpsenderinterface.h',
     94-        'sctputils.cc',
     95-        'sctputils.h',
     96-        'statscollector.cc',
     97-        'statscollector.h',
     98-        'statstypes.cc',
     99-        'statstypes.h',
     100-        'streamcollection.h',
     101-        'videocapturertracksource.cc',
     102-        'videocapturertracksource.h',
     103-        'videosourceproxy.h',
     104-        'videotrack.cc',
     105-        'videotrack.h',
     106-        'videotracksource.cc',
     107-        'videotracksource.h',
     108-        'webrtcsdp.cc',
     109-        'webrtcsdp.h',
     110-        'webrtcsession.cc',
     111-        'webrtcsession.h',
     112-        'webrtcsessiondescriptionfactory.cc',
     113-        'webrtcsessiondescriptionfactory.h',
     114-      ],
     115-      # TODO(kjellander): Make the code compile without disabling these flags.
     116-      # See https://bugs.chromium.org/p/webrtc/issues/detail?id=3307
     117-      'cflags': [
     118-        '-Wno-sign-compare',
     119-      ],
     120-      'cflags_cc!': [
     121-        '-Woverloaded-virtual',
     122-      ],
     123-      'conditions': [
     124-        ['clang==1', {
     125-          'cflags!': [
     126-            '-Wextra',
     127+    ['build_have_not == 1', {
     128+      'targets': [
     129+        {
     130+          'target_name': 'libjingle_peerconnection',
     131+          'type': 'static_library',
     132+          'dependencies': [
     133+            '<(webrtc_root)/media/media.gyp:rtc_media',
     134+            '<(webrtc_root)/pc/pc.gyp:rtc_pc',
     135           ],
     136-          'xcode_settings': {
     137-            'WARNING_CFLAGS!': ['-Wextra'],
     138-          },
     139-        }, {
     140+          'sources': [
     141+            'audiotrack.cc',
     142+            'audiotrack.h',
     143+            'datachannel.cc',
     144+            'datachannel.h',
     145+            'datachannelinterface.h',
     146+            'dtlsidentitystore.cc',
     147+            'dtlsidentitystore.h',
     148+            'dtmfsender.cc',
     149+            'dtmfsender.h',
     150+            'dtmfsenderinterface.h',
     151+            'jsep.h',
     152+            'jsepicecandidate.cc',
     153+            'jsepicecandidate.h',
     154+            'jsepsessiondescription.cc',
     155+            'jsepsessiondescription.h',
     156+            'localaudiosource.cc',
     157+            'localaudiosource.h',
     158+            'mediaconstraintsinterface.cc',
     159+            'mediaconstraintsinterface.h',
     160+            'mediacontroller.cc',
     161+            'mediacontroller.h',
     162+            'mediastream.cc',
     163+            'mediastream.h',
     164+            'mediastreaminterface.h',
     165+            'mediastreamobserver.cc',
     166+            'mediastreamobserver.h',
     167+            'mediastreamprovider.h',
     168+            'mediastreamproxy.h',
     169+            'mediastreamtrack.h',
     170+            'mediastreamtrackproxy.h',
     171+            'notifier.h',
     172+            'peerconnection.cc',
     173+            'peerconnection.h',
     174+            'peerconnectionfactory.cc',
     175+            'peerconnectionfactory.h',
     176+            'peerconnectionfactoryproxy.h',
     177+            'peerconnectioninterface.h',
     178+            'peerconnectionproxy.h',
     179+            'proxy.h',
     180+            'remoteaudiosource.cc',
     181+            'remoteaudiosource.h',
     182+            'rtpparameters.h',
     183+            'rtpreceiver.cc',
     184+            'rtpreceiver.h',
     185+            'rtpreceiverinterface.h',
     186+            'rtpsender.cc',
     187+            'rtpsender.h',
     188+            'rtpsenderinterface.h',
     189+            'sctputils.cc',
     190+            'sctputils.h',
     191+            'statscollector.cc',
     192+            'statscollector.h',
     193+            'statstypes.cc',
     194+            'statstypes.h',
     195+            'streamcollection.h',
     196+            'videocapturertracksource.cc',
     197+            'videocapturertracksource.h',
     198+            'videosourceproxy.h',
     199+            'videotrack.cc',
     200+            'videotrack.h',
     201+            'videotracksource.cc',
     202+            'videotracksource.h',
     203+            'webrtcsdp.cc',
     204+            'webrtcsdp.h',
     205+            'webrtcsession.cc',
     206+            'webrtcsession.h',
     207+            'webrtcsessiondescriptionfactory.cc',
     208+            'webrtcsessiondescriptionfactory.h',
     209+          ],
     210+          # TODO(kjellander): Make the code compile without disabling these flags.
     211+          # See https://bugs.chromium.org/p/webrtc/issues/detail?id=3307
     212           'cflags': [
     213-            '-Wno-maybe-uninitialized',  # Only exists for GCC.
     214+            '-Wno-sign-compare',
     215           ],
     216-        }],
     217-        ['OS=="win"', {
     218-          # Disable warning for signed/unsigned mismatch.
     219-          'msvs_settings': {
     220-            'VCCLCompilerTool': {
     221-              'AdditionalOptions!': ['/we4389'],
     222-            },
     223-          },
     224-        }],
     225-        ['OS=="win" and clang==1', {
     226-          'msvs_settings': {
     227-            'VCCLCompilerTool': {
     228-              'AdditionalOptions': [
     229-                '-Wno-sign-compare',
     230+          'cflags_cc!': [
     231+            '-Woverloaded-virtual',
     232+          ],
     233+          'conditions': [
     234+            ['clang==1', {
     235+              'cflags!': [
     236+                '-Wextra',
     237               ],
     238-            },
     239-          },
     240-        }],
     241-        ['use_quic==1', {
     242+              'xcode_settings': {
     243+                'WARNING_CFLAGS!': ['-Wextra'],
     244+              },
     245+            }, {
     246+              'cflags': [
     247+                '-Wno-maybe-uninitialized',  # Only exists for GCC.
     248+              ],
     249+            }],
     250+            ['OS=="win"', {
     251+              # Disable warning for signed/unsigned mismatch.
     252+              'msvs_settings': {
     253+                'VCCLCompilerTool': {
     254+                  'AdditionalOptions!': ['/we4389'],
     255+                },
     256+              },
     257+            }],
     258+            ['OS=="win" and clang==1', {
     259+              'msvs_settings': {
     260+                'VCCLCompilerTool': {
     261+                  'AdditionalOptions': [
     262+                    '-Wno-sign-compare',
     263+                  ],
     264+                },
     265+              },
     266+            }],
     267+            ['use_quic==1', {
     268+              'dependencies': [
     269+                '<(DEPTH)/third_party/libquic/libquic.gyp:libquic',
     270+              ],
     271+              'sources': [
     272+                'quicdatachannel.cc',
     273+                'quicdatachannel.h',
     274+                'quicdatatransport.cc',
     275+                'quicdatatransport.h',
     276+              ],
     277+              'export_dependent_settings': [
     278+                '<(DEPTH)/third_party/libquic/libquic.gyp:libquic',
     279+              ],
     280+            }],
     281+          ],
     282+        },  # target libjingle_peerconnection
     283+      ],  # targets
     284+    }],
     285+    ['build_have_not == 0', {
     286+      'targets': [
     287+        {
     288+          'target_name': 'libjingle_peerconnection_not',
     289+          'type': 'static_library',
     290           'dependencies': [
     291-            '<(DEPTH)/third_party/libquic/libquic.gyp:libquic',
     292+            '<(webrtc_root)/media/media.gyp:rtc_media_not',
     293+            '<(webrtc_root)/pc/pc.gyp:rtc_pc',
     294+            '<(webrtc_root)/system_wrappers/system_wrappers.gyp:field_trial_default',
     295           ],
     296           'sources': [
     297-            'quicdatachannel.cc',
     298-            'quicdatachannel.h',
     299-            'quicdatatransport.cc',
     300-            'quicdatatransport.h',
     301+            'datachannel.cc',
     302+            'datachannel.h',
     303+            'datachannelinterface.h',
     304+            'dtlsidentitystore.cc',
     305+            'dtlsidentitystore.h',
     306+            'dtmfsender.cc',
     307+            'dtmfsender.h',
     308+            'dtmfsenderinterface.h',
     309+            'jsep.h',
     310+            'jsepicecandidate.cc',
     311+            'jsepicecandidate.h',
     312+            'jsepsessiondescription.cc',
     313+            'jsepsessiondescription.h',
     314+            'mediaconstraintsinterface.cc',
     315+            'mediaconstraintsinterface.h',
     316+            'mediacontroller.cc',
     317+            'mediacontroller.h',
     318+            'mediastreamobserver.h',
     319+            'notifier.h',
     320+            'peerconnection.cc',
     321+            'peerconnection.h',
     322+            'peerconnectionfactory.cc',
     323+            'peerconnectionfactory.h',
     324+            'peerconnectionfactoryproxy.h',
     325+            'peerconnectioninterface.h',
     326+            'peerconnectionproxy.h',
     327+            'proxy.h',
     328+            'rtpparameters.h',
     329+            'rtpreceiver.h',
     330+            'rtpreceiverinterface.h',
     331+            'rtpsender.h',
     332+            'rtpsenderinterface.h',
     333+            'sctputils.cc',
     334+            'sctputils.h',
     335+            'statscollector.cc',
     336+            'statscollector.h',
     337+            'statstypes.cc',
     338+            'statstypes.h',
     339+            'streamcollection.h',
     340+            'webrtcsdp.cc',
     341+            'webrtcsdp.h',
     342+            'webrtcsession.cc',
     343+            'webrtcsession.h',
     344+            'webrtcsessiondescriptionfactory.cc',
     345+            'webrtcsessiondescriptionfactory.h',
     346           ],
     347-          'export_dependent_settings': [
     348-            '<(DEPTH)/third_party/libquic/libquic.gyp:libquic',
     349+          # TODO(kjellander): Make the code compile without disabling these flags.
     350+          # See https://bugs.chromium.org/p/webrtc/issues/detail?id=3307
     351+          'cflags': [
     352+            '-Wno-sign-compare',
     353           ],
     354-        }],
     355-      ],
     356-    },  # target libjingle_peerconnection
     357-  ],  # targets
     358+          'cflags_cc!': [
     359+            '-Woverloaded-virtual',
     360+          ],
     361+          'conditions': [
     362+            ['clang==1', {
     363+              'cflags!': [
     364+                '-Wextra',
     365+              ],
     366+              'xcode_settings': {
     367+                'WARNING_CFLAGS!': ['-Wextra'],
     368+              },
     369+            }, {
     370+              'cflags': [
     371+                '-Wno-maybe-uninitialized',  # Only exists for GCC.
     372+              ],
     373+            }],
     374+            ['OS=="win"', {
     375+              # Disable warning for signed/unsigned mismatch.
     376+              'msvs_settings': {
     377+                'VCCLCompilerTool': {
     378+                  'AdditionalOptions!': ['/we4389'],
     379+                },
     380+              },
     381+            }],
     382+            ['OS=="win" and clang==1', {
     383+              'msvs_settings': {
     384+                'VCCLCompilerTool': {
     385+                  'AdditionalOptions': [
     386+                    '-Wno-sign-compare',
     387+                  ],
     388+                },
     389+              },
     390+            }],
     391+            ['use_quic==1', {
     392+              'dependencies': [
     393+                '<(DEPTH)/third_party/libquic/libquic.gyp:libquic',
     394+              ],
     395+              'sources': [
     396+                'quicdatachannel.cc',
     397+                'quicdatachannel.h',
     398+                'quicdatatransport.cc',
     399+                'quicdatatransport.h',
     400+              ],
     401+              'export_dependent_settings': [
     402+                '<(DEPTH)/third_party/libquic/libquic.gyp:libquic',
     403+              ],
     404+            }],
     405+          ],
     406+        },  # target libjingle_peerconnection_not
     407+      ],  # targets
     408+    }],
     409+  ],  # conditions
     410 }
     411diff --git a/webrtc/api/mediacontroller.cc b/webrtc/api/mediacontroller.cc
     412index 2e4501b..651e769 100644
     413--- a/webrtc/api/mediacontroller.cc
     414+++ b/webrtc/api/mediacontroller.cc
     415@@ -35,9 +35,15 @@ class MediaController : public webrtc::MediaControllerInterface,
     416         media_config_(media_config),
     417         channel_manager_(channel_manager) {
     418     RTC_DCHECK(worker_thread);
     419+
     420+    #ifdef HAVE_NOT
     421+
     422     worker_thread_->Invoke<void>(
     423         rtc::Bind(&MediaController::Construct_w, this,
     424                   channel_manager_->media_engine()));
     425+
     426+    #endif  // HAVE_NOT
     427+
     428   }
     429   ~MediaController() override {
     430     Close();
     431diff --git a/webrtc/api/peerconnection.cc b/webrtc/api/peerconnection.cc
     432index dda0eeb..04c6be5 100644
     433--- a/webrtc/api/peerconnection.cc
     434+++ b/webrtc/api/peerconnection.cc
     435@@ -49,10 +49,14 @@ using webrtc::PeerConnectionInterface;
     436 using webrtc::RtpSenderInterface;
     437 using webrtc::StreamCollection;
     438 
     439+#ifdef HAVE_NOT
     440+
     441 static const char kDefaultStreamLabel[] = "default";
     442 static const char kDefaultAudioTrackLabel[] = "defaulta0";
     443 static const char kDefaultVideoTrackLabel[] = "defaultv0";
     444 
     445+#endif  // HAVE_NOT
     446+
     447 // The min number of tokens must present in Turn host uri.
     448 // e.g. user@turn.example.org
     449 static const size_t kTurnHostTokensNum = 2;
     450@@ -313,6 +317,8 @@ bool ParseIceServerUrl(const PeerConnectionInterface::IceServer& server,
     451   return true;
     452 }
     453 
     454+#ifdef HAVE_NOT
     455+
     456 // Check if we can send |new_stream| on a PeerConnection.
     457 bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams,
     458                             webrtc::MediaStreamInterface* new_stream) {
     459@@ -327,6 +333,8 @@ bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams,
     460   return true;
     461 }
     462 
     463+#endif  // HAVE_NOT
     464+
     465 bool MediaContentDirectionHasSend(cricket::MediaContentDirection dir) {
     466   return dir == cricket::MD_SENDONLY || dir == cricket::MD_SENDRECV;
     467 }
     468@@ -626,6 +634,8 @@ PeerConnection::remote_streams() {
     469   return remote_streams_;
     470 }
     471 
     472+#ifdef HAVE_NOT
     473+
     474 bool PeerConnection::AddStream(MediaStreamInterface* local_stream) {
     475   TRACE_EVENT0("webrtc", "PeerConnection::AddStream");
     476   if (IsClosed()) {
     477@@ -801,6 +811,8 @@ rtc::scoped_refptr<RtpSenderInterface> PeerConnection::CreateSender(
     478   return new_sender;
     479 }
     480 
     481+#endif  // HAVE_NOT
     482+
     483 std::vector<rtc::scoped_refptr<RtpSenderInterface>> PeerConnection::GetSenders()
     484     const {
     485   return senders_;
     486@@ -1010,6 +1022,8 @@ void PeerConnection::SetLocalDescription(
     487     AllocateSctpSids(role);
     488   }
     489 
     490+  #ifdef HAVE_NOT
     491+
     492   // Update state and SSRC of local MediaStreams and DataChannels based on the
     493   // local session description.
     494   const cricket::ContentInfo* audio_content =
     495@@ -1038,6 +1052,8 @@ void PeerConnection::SetLocalDescription(
     496     }
     497   }
     498 
     499+  #endif  // HAVE_NOT
     500+
     501   const cricket::ContentInfo* data_content =
     502       GetFirstDataContent(desc->description());
     503   if (data_content) {
     504@@ -1089,14 +1105,26 @@ void PeerConnection::SetRemoteDescription(
     505   }
     506 
     507   const cricket::SessionDescription* remote_desc = desc->description();
     508+
     509+  const cricket::DataContentDescription* data_desc =
     510+      GetFirstDataContentDescription(remote_desc);
     511+
     512+  // Update the DataChannels with the information from the remote peer.
     513+  if (data_desc) {
     514+    if (rtc::starts_with(data_desc->protocol().data(),
     515+                         cricket::kMediaProtocolRtpPrefix)) {
     516+      UpdateRemoteRtpDataChannels(GetActiveStreams(data_desc));
     517+    }
     518+  }
     519+
     520+  #ifdef HAVE_NOT
     521+
     522   const cricket::ContentInfo* audio_content = GetFirstAudioContent(remote_desc);
     523   const cricket::ContentInfo* video_content = GetFirstVideoContent(remote_desc);
     524   const cricket::AudioContentDescription* audio_desc =
     525       GetFirstAudioContentDescription(remote_desc);
     526   const cricket::VideoContentDescription* video_desc =
     527       GetFirstVideoContentDescription(remote_desc);
     528-  const cricket::DataContentDescription* data_desc =
     529-      GetFirstDataContentDescription(remote_desc);
     530 
     531   // Check if the descriptions include streams, just in case the peer supports
     532   // MSID, but doesn't indicate so with "a=msid-semantic".
     533@@ -1140,14 +1168,6 @@ void PeerConnection::SetRemoteDescription(
     534     }
     535   }
     536 
     537-  // Update the DataChannels with the information from the remote peer.
     538-  if (data_desc) {
     539-    if (rtc::starts_with(data_desc->protocol().data(),
     540-                         cricket::kMediaProtocolRtpPrefix)) {
     541-      UpdateRemoteRtpDataChannels(GetActiveStreams(data_desc));
     542-    }
     543-  }
     544-
     545   // Iterate new_streams and notify the observer about new MediaStreams.
     546   for (size_t i = 0; i < new_streams->count(); ++i) {
     547     MediaStreamInterface* new_stream = new_streams->at(i);
     548@@ -1155,6 +1175,8 @@ void PeerConnection::SetRemoteDescription(
     549     observer_->OnAddStream(new_stream);
     550   }
     551 
     552+  #endif  // HAVE_NOT
     553+
     554   UpdateEndedRemoteMediaStreams();
     555 
     556   SetSessionDescriptionMsg* msg = new SetSessionDescriptionMsg(observer);
     557@@ -1297,6 +1319,8 @@ void PeerConnection::OnMessage(rtc::Message* msg) {
     558   }
     559 }
     560 
     561+#ifdef HAVE_NOT
     562+
     563 void PeerConnection::CreateAudioReceiver(MediaStreamInterface* stream,
     564                                          const std::string& track_id,
     565                                          uint32_t ssrc) {
     566@@ -1314,6 +1338,8 @@ void PeerConnection::CreateVideoReceiver(MediaStreamInterface* stream,
     567                            session_.get())));
     568 }
     569 
     570+#endif  // HAVE_NOT
     571+
     572 // TODO(deadbeef): Keep RtpReceivers around even if track goes away in remote
     573 // description.
     574 void PeerConnection::DestroyReceiver(const std::string& track_id) {
     575@@ -1392,6 +1418,8 @@ void PeerConnection::ChangeSignalingState(
     576   observer_->OnSignalingChange(signaling_state_);
     577 }
     578 
     579+#ifdef HAVE_NOT
     580+
     581 void PeerConnection::OnAudioTrackAdded(AudioTrackInterface* track,
     582                                        MediaStreamInterface* stream) {
     583   auto sender = FindSenderForTrack(track);
     584@@ -1468,6 +1496,8 @@ void PeerConnection::OnVideoTrackRemoved(VideoTrackInterface* track,
     585   senders_.erase(sender);
     586 }
     587 
     588+#endif  // HAVE_NOT
     589+
     590 void PeerConnection::PostSetSessionDescriptionFailure(
     591     SetSessionDescriptionObserver* observer,
     592     const std::string& error) {
     593@@ -1580,6 +1610,8 @@ bool PeerConnection::GetOptionsForAnswer(
     594   return true;
     595 }
     596 
     597+#ifdef HAVE_NOT
     598+
     599 void PeerConnection::RemoveTracks(cricket::MediaType media_type) {
     600   UpdateLocalTracks(std::vector<cricket::StreamParams>(), media_type);
     601   UpdateRemoteStreamsList(std::vector<cricket::StreamParams>(), false,
     602@@ -1706,6 +1738,8 @@ void PeerConnection::OnRemoteTrackRemoved(const std::string& stream_label,
     603   }
     604 }
     605 
     606+#endif  // HAVE_NOT
     607+
     608 void PeerConnection::UpdateEndedRemoteMediaStreams() {
     609   std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams_to_remove;
     610   for (size_t i = 0; i < remote_streams_->count(); ++i) {
     611@@ -1721,6 +1755,8 @@ void PeerConnection::UpdateEndedRemoteMediaStreams() {
     612   }
     613 }
     614 
     615+#ifdef HAVE_NOT
     616+
     617 void PeerConnection::UpdateLocalTracks(
     618     const std::vector<cricket::StreamParams>& streams,
     619     cricket::MediaType media_type) {
     620@@ -1759,6 +1795,8 @@ void PeerConnection::UpdateLocalTracks(
     621   }
     622 }
     623 
     624+#endif  // HAVE_NOT
     625+
     626 void PeerConnection::OnLocalTrackSeen(const std::string& stream_label,
     627                                       const std::string& track_id,
     628                                       uint32_t ssrc,
     629diff --git a/webrtc/api/peerconnection.h b/webrtc/api/peerconnection.h
     630index 8ba7e58..99a695a 100644
     631--- a/webrtc/api/peerconnection.h
     632+++ b/webrtc/api/peerconnection.h
     633@@ -75,15 +75,19 @@ class PeerConnection : public PeerConnectionInterface,
     634 
     635   rtc::scoped_refptr<StreamCollectionInterface> local_streams() override;
     636   rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override;
     637+
     638+  virtual WebRtcSession* session() { return session_.get(); }
     639+
     640+  #ifdef HAVE_NOT
     641+
     642   bool AddStream(MediaStreamInterface* local_stream) override;
     643   void RemoveStream(MediaStreamInterface* local_stream) override;
     644 
     645   rtc::scoped_refptr<RtpSenderInterface> AddTrack(
     646       MediaStreamTrackInterface* track,
     647       std::vector<MediaStreamInterface*> streams) override;
     648-  bool RemoveTrack(RtpSenderInterface* sender) override;
     649 
     650-  virtual WebRtcSession* session() { return session_.get(); }
     651+  bool RemoveTrack(RtpSenderInterface* sender) override;
     652 
     653   rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
     654       AudioTrackInterface* track) override;
     655@@ -92,6 +96,8 @@ class PeerConnection : public PeerConnectionInterface,
     656       const std::string& kind,
     657       const std::string& stream_id) override;
     658 
     659+  #endif  // HAVE_NOT
     660+
     661   std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
     662       const override;
     663   std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
     664@@ -195,6 +201,8 @@ class PeerConnection : public PeerConnectionInterface,
     665   void OnSessionStateChange(WebRtcSession* session, WebRtcSession::State state);
     666   void ChangeSignalingState(SignalingState signaling_state);
     667 
     668+  #ifdef HAVE_NOT
     669+
     670   // Signals from MediaStreamObserver.
     671   void OnAudioTrackAdded(AudioTrackInterface* track,
     672                          MediaStreamInterface* stream);
     673@@ -205,6 +213,8 @@ class PeerConnection : public PeerConnectionInterface,
     674   void OnVideoTrackRemoved(VideoTrackInterface* track,
     675                            MediaStreamInterface* stream);
     676 
     677+  #endif  // HAVE_NOT
     678+
     679   rtc::Thread* signaling_thread() const {
     680     return factory_->signaling_thread();
     681   }
     682diff --git a/webrtc/api/peerconnectionfactory.cc b/webrtc/api/peerconnectionfactory.cc
     683index 9cb5b46..60b4bde 100644
     684--- a/webrtc/api/peerconnectionfactory.cc
     685+++ b/webrtc/api/peerconnectionfactory.cc
     686@@ -170,12 +170,18 @@ bool PeerConnectionFactory::Initialize() {
     687     return false;
     688   }
     689 
     690+  cricket::MediaEngineInterface* media_engine = nullptr;
     691+
     692+  #ifdef HAVE_NOT
     693+
     694   // TODO:  Need to make sure only one VoE is created inside
     695   // WebRtcMediaEngine.
     696-  cricket::MediaEngineInterface* media_engine =
     697+  media_engine =
     698       worker_thread_->Invoke<cricket::MediaEngineInterface*>(rtc::Bind(
     699       &PeerConnectionFactory::CreateMediaEngine_w, this));
     700 
     701+  #endif  // HAVE_NOT
     702+
     703   channel_manager_.reset(new cricket::ChannelManager(
     704       media_engine, worker_thread_, network_thread_));
     705 
     706@@ -190,6 +196,8 @@ bool PeerConnectionFactory::Initialize() {
     707   return true;
     708 }
     709 
     710+#ifdef HAVE_NOT
     711+
     712 rtc::scoped_refptr<AudioSourceInterface>
     713 PeerConnectionFactory::CreateAudioSource(
     714     const MediaConstraintsInterface* constraints) {
     715@@ -228,6 +236,8 @@ PeerConnectionFactory::CreateVideoSource(cricket::VideoCapturer* capturer) {
     716                                        source);
     717 }
     718 
     719+#endif  // HAVE_NOT
     720+
     721 bool PeerConnectionFactory::StartAecDump(rtc::PlatformFile file,
     722                                          int64_t max_size_bytes) {
     723   RTC_DCHECK(signaling_thread_->IsCurrent());
     724@@ -301,6 +311,8 @@ PeerConnectionFactory::CreatePeerConnection(
     725   return PeerConnectionProxy::Create(signaling_thread(), pc);
     726 }
     727 
     728+#ifdef HAVE_NOT
     729+
     730 rtc::scoped_refptr<MediaStreamInterface>
     731 PeerConnectionFactory::CreateLocalMediaStream(const std::string& label) {
     732   RTC_DCHECK(signaling_thread_->IsCurrent());
     733@@ -325,6 +337,8 @@ PeerConnectionFactory::CreateAudioTrack(const std::string& id,
     734   return AudioTrackProxy::Create(signaling_thread_, track);
     735 }
     736 
     737+#endif  // HAVE_NOT
     738+
     739 webrtc::MediaControllerInterface* PeerConnectionFactory::CreateMediaController(
     740     const cricket::MediaConfig& config) const {
     741   RTC_DCHECK(signaling_thread_->IsCurrent());
     742@@ -347,6 +361,8 @@ rtc::Thread* PeerConnectionFactory::network_thread() {
     743   return network_thread_;
     744 }
     745 
     746+#ifdef HAVE_NOT
     747+
     748 cricket::MediaEngineInterface* PeerConnectionFactory::CreateMediaEngine_w() {
     749   ASSERT(worker_thread_ == rtc::Thread::Current());
     750   return cricket::WebRtcMediaEngineFactory::Create(
     751@@ -354,4 +370,6 @@ cricket::MediaEngineInterface* PeerConnectionFactory::CreateMediaEngine_w() {
     752       video_decoder_factory_.get());
     753 }
     754 
     755+#endif  // HAVE_NOT
     756+
     757 }  // namespace webrtc
     758diff --git a/webrtc/api/peerconnectionfactory.h b/webrtc/api/peerconnectionfactory.h
     759index 21165cf..26fb972 100644
     760--- a/webrtc/api/peerconnectionfactory.h
     761+++ b/webrtc/api/peerconnectionfactory.h
     762@@ -54,6 +54,8 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface {
     763 
     764   bool Initialize();
     765 
     766+  #ifdef HAVE_NOT
     767+
     768   rtc::scoped_refptr<MediaStreamInterface>
     769       CreateLocalMediaStream(const std::string& label) override;
     770 
     771@@ -81,6 +83,11 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface {
     772       CreateAudioTrack(const std::string& id,
     773                        AudioSourceInterface* audio_source) override;
     774 
     775+  #endif  // HAVE_NOT
     776+
     777+  virtual webrtc::MediaControllerInterface* CreateMediaController(
     778+      const cricket::MediaConfig& config) const;
     779+
     780   bool StartAecDump(rtc::PlatformFile file, int64_t max_size_bytes) override;
     781   void StopAecDump() override;
     782   bool StartRtcEventLog(rtc::PlatformFile file) override {
     783@@ -90,8 +97,6 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface {
     784                         int64_t max_size_bytes) override;
     785   void StopRtcEventLog() override;
     786 
     787-  virtual webrtc::MediaControllerInterface* CreateMediaController(
     788-      const cricket::MediaConfig& config) const;
     789   virtual rtc::Thread* signaling_thread();
     790   virtual rtc::Thread* worker_thread();
     791   virtual rtc::Thread* network_thread();
     792@@ -109,7 +114,9 @@ class PeerConnectionFactory : public PeerConnectionFactoryInterface {
     793   virtual ~PeerConnectionFactory();
     794 
     795  private:
     796+  #ifdef HAVE_NOT
     797   cricket::MediaEngineInterface* CreateMediaEngine_w();
     798+  #endif  // HAVE_NOT
     799 
     800   bool owns_ptrs_;
     801   bool wraps_current_thread_;
     802diff --git a/webrtc/api/peerconnectionfactoryproxy.h b/webrtc/api/peerconnectionfactoryproxy.h
     803index c357de9..0a75d1f 100644
     804--- a/webrtc/api/peerconnectionfactoryproxy.h
     805+++ b/webrtc/api/peerconnectionfactoryproxy.h
     806@@ -46,6 +46,9 @@ BEGIN_SIGNALING_PROXY_MAP(PeerConnectionFactory)
     807             rtc::Bind(&PeerConnectionFactoryProxy::CreatePeerConnection_ot,
     808                       this, a1, a3.release(), a4.release(), a5));
     809   }
     810+
     811+  #ifdef HAVE_NOT
     812+
     813   PROXY_METHOD1(rtc::scoped_refptr<MediaStreamInterface>,
     814                 CreateLocalMediaStream, const std::string&)
     815   PROXY_METHOD1(rtc::scoped_refptr<AudioSourceInterface>,
     816@@ -66,6 +69,9 @@ BEGIN_SIGNALING_PROXY_MAP(PeerConnectionFactory)
     817                 VideoTrackSourceInterface*)
     818   PROXY_METHOD2(rtc::scoped_refptr<AudioTrackInterface>,
     819                 CreateAudioTrack, const std::string&,  AudioSourceInterface*)
     820+
     821+  #endif  // HAVE_NOT
     822+
     823   PROXY_METHOD2(bool, StartAecDump, rtc::PlatformFile, int64_t)
     824   PROXY_METHOD0(void, StopAecDump)
     825   PROXY_METHOD1(bool, StartRtcEventLog, rtc::PlatformFile)
     826diff --git a/webrtc/api/peerconnectioninterface.h b/webrtc/api/peerconnectioninterface.h
     827index 4fa9bf2..26055d4 100644
     828--- a/webrtc/api/peerconnectioninterface.h
     829+++ b/webrtc/api/peerconnectioninterface.h
     830@@ -344,6 +344,8 @@ class PeerConnectionInterface : public rtc::RefCountInterface {
     831   virtual rtc::scoped_refptr<StreamCollectionInterface>
     832       remote_streams() = 0;
     833 
     834+  #ifdef HAVE_NOT
     835+
     836   // Add a new MediaStream to be sent on this PeerConnection.
     837   // Note that a SessionDescription negotiation is needed before the
     838   // remote peer can receive the stream.
     839@@ -386,6 +388,8 @@ class PeerConnectionInterface : public rtc::RefCountInterface {
     840     return rtc::scoped_refptr<RtpSenderInterface>();
     841   }
     842 
     843+  #endif  // HAVE_NOT
     844+
     845   virtual std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
     846       const {
     847     return std::vector<rtc::scoped_refptr<RtpSenderInterface>>();
     848@@ -589,6 +593,8 @@ class PeerConnectionFactoryInterface : public rtc::RefCountInterface {
     849       std::unique_ptr<DtlsIdentityStoreInterface> dtls_identity_store,
     850       PeerConnectionObserver* observer) = 0;
     851 
     852+  #ifdef HAVE_NOT
     853+
     854   virtual rtc::scoped_refptr<MediaStreamInterface>
     855       CreateLocalMediaStream(const std::string& label) = 0;
     856 
     857@@ -623,6 +629,8 @@ class PeerConnectionFactoryInterface : public rtc::RefCountInterface {
     858       CreateAudioTrack(const std::string& label,
     859                        AudioSourceInterface* source) = 0;
     860 
     861+  #endif  // HAVE_NOT
     862+
     863   // Starts AEC dump using existing file. Takes ownership of |file| and passes
     864   // it on to VoiceEngine (via other objects) immediately, which will take
     865   // the ownerhip. If the operation fails, the file will be closed.
     866diff --git a/webrtc/api/peerconnectionproxy.h b/webrtc/api/peerconnectionproxy.h
     867index d35d5ba..eb74042 100644
     868--- a/webrtc/api/peerconnectionproxy.h
     869+++ b/webrtc/api/peerconnectionproxy.h
     870@@ -22,6 +22,9 @@ BEGIN_SIGNALING_PROXY_MAP(PeerConnection)
     871                 local_streams)
     872   PROXY_METHOD0(rtc::scoped_refptr<StreamCollectionInterface>,
     873                 remote_streams)
     874+
     875+  #ifdef HAVE_NOT
     876+
     877   PROXY_METHOD1(bool, AddStream, MediaStreamInterface*)
     878   PROXY_METHOD1(void, RemoveStream, MediaStreamInterface*)
     879   PROXY_METHOD2(rtc::scoped_refptr<RtpSenderInterface>,
     880@@ -35,6 +38,9 @@ BEGIN_SIGNALING_PROXY_MAP(PeerConnection)
     881                 CreateSender,
     882                 const std::string&,
     883                 const std::string&)
     884+
     885+  #endif  // HAVE_NOT
     886+
     887   PROXY_CONSTMETHOD0(std::vector<rtc::scoped_refptr<RtpSenderInterface>>,
     888                      GetSenders)
     889   PROXY_CONSTMETHOD0(std::vector<rtc::scoped_refptr<RtpReceiverInterface>>,
     890diff --git a/webrtc/api/statscollector.cc b/webrtc/api/statscollector.cc
     891index df1d0aa..ec69b8f 100644
     892--- a/webrtc/api/statscollector.cc
     893+++ b/webrtc/api/statscollector.cc
     894@@ -847,6 +847,8 @@ void StatsCollector::ExtractVideoInfo(
     895 void StatsCollector::ExtractSenderInfo() {
     896   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
     897 
     898+  #ifdef HAVE_NOT
     899+
     900   for (const auto& sender : pc_->GetSenders()) {
     901     // TODO(nisse): SSRC == 0 currently means none. Delete check when
     902     // that is fixed.
     903@@ -875,6 +877,8 @@ void StatsCollector::ExtractSenderInfo() {
     904     report->AddInt(StatsReport::kStatsValueNameFrameHeightInput,
     905                    stats.input_height);
     906   }
     907+
     908+  #endif  // HAVE_NOT
     909 }
     910 
     911 void StatsCollector::ExtractDataInfo() {
     912diff --git a/webrtc/build/common.gypi b/webrtc/build/common.gypi
     913index 26acf4b..57c02eb 100644
     914--- a/webrtc/build/common.gypi
     915+++ b/webrtc/build/common.gypi
     916@@ -69,6 +69,7 @@
     917     },
     918     'build_with_chromium%': '<(build_with_chromium)',
     919     'build_with_mozilla%': '<(build_with_mozilla)',
     920+    'build_have_not%': 0,
     921     'build_libevent%': '<(build_libevent)',
     922     'enable_libevent%': '<(enable_libevent)',
     923     'webrtc_root%': '<(webrtc_root)',
     924diff --git a/webrtc/call.h b/webrtc/call.h
     925index 80134fa..7cbe6ba 100644
     926--- a/webrtc/call.h
     927+++ b/webrtc/call.h
     928@@ -99,6 +99,8 @@ class Call {
     929 
     930   static Call* Create(const Call::Config& config);
     931 
     932+  #ifdef HAVE_NOT
     933+
     934   virtual AudioSendStream* CreateAudioSendStream(
     935       const AudioSendStream::Config& config) = 0;
     936   virtual void DestroyAudioSendStream(AudioSendStream* send_stream) = 0;
     937@@ -118,6 +120,8 @@ class Call {
     938   virtual void DestroyVideoReceiveStream(
     939       VideoReceiveStream* receive_stream) = 0;
     940 
     941+  #endif  // HAVE_NOT
     942+
     943   // All received RTP and RTCP packets for the call should be inserted to this
     944   // PacketReceiver. The PacketReceiver pointer is valid as long as the
     945   // Call instance exists.
     946diff --git a/webrtc/call/call.cc b/webrtc/call/call.cc
     947index f7c66db..a3f18dc 100644
     948--- a/webrtc/call/call.cc
     949+++ b/webrtc/call/call.cc
     950@@ -61,6 +61,8 @@ class Call : public webrtc::Call,
     951 
     952   PacketReceiver* Receiver() override;
     953 
     954+  #ifdef HAVE_NOT
     955+
     956   webrtc::AudioSendStream* CreateAudioSendStream(
     957       const webrtc::AudioSendStream::Config& config) override;
     958   void DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) override;
     959@@ -80,6 +82,8 @@ class Call : public webrtc::Call,
     960   void DestroyVideoReceiveStream(
     961       webrtc::VideoReceiveStream* receive_stream) override;
     962 
     963+  #endif  // HAVE_NOT
     964+
     965   Stats GetStats() const override;
     966 
     967   DeliveryStatus DeliverPacket(MediaType media_type,
     968@@ -112,11 +116,13 @@ class Call : public webrtc::Call,
     969       EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
     970 
     971   VoiceEngine* voice_engine() {
     972+    #ifdef HAVE_NOT
     973     internal::AudioState* audio_state =
     974         static_cast<internal::AudioState*>(config_.audio_state.get());
     975     if (audio_state)
     976       return audio_state->voice_engine();
     977     else
     978+    #endif  // HAVE_NOT
     979       return nullptr;
     980   }
     981 
     982@@ -223,11 +229,16 @@ Call::Call(const Call::Config& config)
     983     RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
     984                   config.bitrate_config.start_bitrate_bps);
     985   }
     986+
     987+  #ifdef HAVE_NOT
     988+
     989   if (config.audio_state.get()) {
     990     ScopedVoEInterface<VoECodec> voe_codec(voice_engine());
     991     event_log_ = voe_codec->GetEventLog();
     992   }
     993 
     994+  #endif  // HAVE_NOT
     995+
     996   Trace::CreateTrace();
     997   call_stats_->RegisterStatsObserver(congestion_controller_.get());
     998 
     999@@ -323,6 +334,8 @@ PacketReceiver* Call::Receiver() {
     1000   return this;
     1001 }
     1002 
     1003+#ifdef HAVE_NOT
     1004+
     1005 webrtc::AudioSendStream* Call::CreateAudioSendStream(
     1006     const webrtc::AudioSendStream::Config& config) {
     1007   TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream");
     1008@@ -522,6 +535,8 @@ void Call::DestroyVideoReceiveStream(
     1009   delete receive_stream_impl;
     1010 }
     1011 
     1012+#endif  // HAVE_NOT
     1013+
     1014 Call::Stats Call::GetStats() const {
     1015   // TODO(solenberg): Some test cases in EndToEndTest use this from a different
     1016   // thread. Re-enable once that is fixed.
     1017@@ -581,6 +596,9 @@ void Call::SignalChannelNetworkState(MediaType media, NetworkState state) {
     1018   }
     1019 
     1020   UpdateAggregateNetworkState();
     1021+
     1022+  #ifdef HAVE_NOT
     1023+
     1024   {
     1025     ReadLockScoped read_lock(*send_crit_);
     1026     for (auto& kv : audio_send_ssrcs_) {
     1027@@ -599,6 +617,9 @@ void Call::SignalChannelNetworkState(MediaType media, NetworkState state) {
     1028       kv.second->SignalNetworkState(video_network_state_);
     1029     }
     1030   }
     1031+
     1032+  #endif  // HAVE_NOT
     1033+
     1034 }
     1035 
     1036 // TODO(honghaiz): Add tests for this method.
     1037@@ -684,8 +705,10 @@ void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
     1038     if (video_send_streams_.empty())
     1039       return;
     1040 
     1041+    #ifdef HAVE_NOT
     1042     for (VideoSendStream* stream : video_send_streams_)
     1043       pad_up_to_bitrate_bps += stream->GetPaddingNeededBps();
     1044+    #endif  // HAVE_NOT
     1045   }
     1046   // Allocated bitrate might be higher than bitrate estimate if enforcing min
     1047   // bitrate, or lower if estimate is higher than the sum of max bitrates, so
     1048@@ -709,6 +732,8 @@ void Call::ConfigureSync(const std::string& sync_group) {
     1049   if (voice_engine() == nullptr || sync_group.empty())
     1050     return;
     1051 
     1052+  #ifdef HAVE_NOT
     1053+
     1054   AudioReceiveStream* sync_audio_stream = nullptr;
     1055   // Find existing audio stream.
     1056   const auto it = sync_stream_mapping_.find(sync_group);
     1057@@ -750,6 +775,9 @@ void Call::ConfigureSync(const std::string& sync_group) {
     1058       video_stream->SetSyncChannel(voice_engine(), -1);
     1059     }
     1060   }
     1061+
     1062+  #endif  // HAVE_NOT
     1063+
     1064 }
     1065 
     1066 PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
     1067@@ -761,6 +789,9 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
     1068   //             there's no receiver of the packet.
     1069   received_rtcp_bytes_ += length;
     1070   bool rtcp_delivered = false;
     1071+
     1072+  #ifdef HAVE_NOT
     1073+
     1074   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     1075     ReadLockScoped read_lock(*receive_crit_);
     1076     for (VideoReceiveStream* stream : video_receive_streams_) {
     1077@@ -790,6 +821,8 @@ PacketReceiver::DeliveryStatus Call::DeliverRtcp(MediaType media_type,
     1078     }
     1079   }
     1080 
     1081+  #endif  // HAVE_NOT
     1082+
     1083   if (event_log_ && rtcp_delivered)
     1084     event_log_->LogRtcpPacket(kIncomingPacket, media_type, packet, length);
     1085 
     1086@@ -809,8 +842,11 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
     1087   if (first_rtp_packet_received_ms_ == -1)
     1088     first_rtp_packet_received_ms_ = last_rtp_packet_received_ms_;
     1089 
     1090+  #ifdef HAVE_NOT
     1091+
     1092   uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
     1093   ReadLockScoped read_lock(*receive_crit_);
     1094+
     1095   if (media_type == MediaType::ANY || media_type == MediaType::AUDIO) {
     1096     auto it = audio_receive_ssrcs_.find(ssrc);
     1097     if (it != audio_receive_ssrcs_.end()) {
     1098@@ -835,6 +871,9 @@ PacketReceiver::DeliveryStatus Call::DeliverRtp(MediaType media_type,
     1099       return status;
     1100     }
     1101   }
     1102+
     1103+  #endif  // HAVE_NOT
     1104+
     1105   return DELIVERY_UNKNOWN_SSRC;
     1106 }
     1107 
     1108diff --git a/webrtc/call/webrtc_call.gypi b/webrtc/call/webrtc_call.gypi
     1109index 455a11a..351f1b5 100644
     1110--- a/webrtc/call/webrtc_call.gypi
     1111+++ b/webrtc/call/webrtc_call.gypi
     1112@@ -15,10 +15,10 @@
     1113       '<(webrtc_root)/webrtc.gyp:rtc_event_log',
     1114     ],
     1115     'webrtc_call_sources': [
     1116-      'call/bitrate_allocator.cc',
     1117-      'call/call.cc',
     1118-      'call/transport_adapter.cc',
     1119-      'call/transport_adapter.h',
     1120+      '<(webrtc_root)/call/bitrate_allocator.cc',
     1121+      '<(webrtc_root)/call/call.cc',
     1122+      '<(webrtc_root)/call/transport_adapter.cc',
     1123+      '<(webrtc_root)/call/transport_adapter.h',
     1124     ],
     1125   },
     1126 }
     1127diff --git a/webrtc/media/media.gyp b/webrtc/media/media.gyp
     1128index deb730a..60bb7e4 100644
     1129--- a/webrtc/media/media.gyp
     1130+++ b/webrtc/media/media.gyp
     1131@@ -7,9 +7,80 @@
     1132 # be found in the AUTHORS file in the root of the source tree.
     1133 
     1134 {
     1135-  'includes': [ '../build/common.gypi', ],
     1136+  'includes': [
     1137+    '../build/common.gypi',
     1138+    '../call/webrtc_call.gypi',
     1139+  ],
     1140   'targets': [
     1141     {
     1142+      'target_name': 'rtc_media_not',
     1143+      'type': 'static_library',
     1144+      'dependencies': [
     1145+        '<(webrtc_root)/system_wrappers/system_wrappers.gyp:metrics_default',
     1146+        '<(webrtc_root)/system_wrappers/system_wrappers.gyp:system_wrappers',
     1147+        '<(webrtc_root)/p2p/p2p.gyp:rtc_p2p',
     1148+        '<@(webrtc_call_dependencies)',
     1149+      ],
     1150+      'sources': [
     1151+        '<(webrtc_root)/call.h',
     1152+        '<@(webrtc_call_sources)',
     1153+        '<(webrtc_root)/video/call_stats.cc',
     1154+        '<(webrtc_root)/video/call_stats.h',
     1155+        '<(webrtc_root)/video/send_delay_stats.cc',
     1156+        '<(webrtc_root)/video/send_delay_stats.h',
     1157+        '<(webrtc_root)/video/vie_remb.cc',
     1158+        '<(webrtc_root)/video/vie_remb.h',
     1159+        '<(webrtc_root)/modules/utility/include/process_thread.h',
     1160+        '<(webrtc_root)/modules/utility/source/process_thread_impl.cc',
     1161+        '<(webrtc_root)/modules/utility/source/process_thread_impl.h',
     1162+        'base/codec.cc',
     1163+        'base/codec.h',
     1164+        'base/mediachannel.h',
     1165+        'base/mediaconstants.cc',
     1166+        'base/mediaconstants.h',
     1167+        'base/mediaengine.cc',
     1168+        'base/mediaengine.h',
     1169+        'base/rtpdataengine.cc',
     1170+        'base/rtpdataengine.h',
     1171+        'base/rtputils.cc',
     1172+        'base/rtputils.h',
     1173+        'base/streamparams.cc',
     1174+        'base/streamparams.h',
     1175+        'base/turnutils.cc',
     1176+        'base/turnutils.h',
     1177+        'sctp/sctpdataengine.cc',
     1178+        'sctp/sctpdataengine.h',
     1179+      ],
     1180+      # TODO(kjellander): Make the code compile without disabling these flags.
     1181+      # See https://bugs.chromium.org/p/webrtc/issues/detail?id=3307
     1182+      'cflags': [
     1183+        '-Wno-deprecated-declarations',
     1184+      ],
     1185+      'cflags!': [
     1186+        '-Wextra',
     1187+      ],
     1188+      'cflags_cc!': [
     1189+        '-Woverloaded-virtual',
     1190+      ],
     1191+      'msvs_disabled_warnings': [
     1192+        4245,  # conversion from 'int' to 'size_t', signed/unsigned mismatch.
     1193+        4267,  # conversion from 'size_t' to 'int', possible loss of data.
     1194+        4389,  # signed/unsigned mismatch.
     1195+      ],
     1196+      'conditions': [
     1197+        ['build_usrsctp==1', {
     1198+          'include_dirs': [
     1199+            # TODO(jiayl): move this into the direct_dependent_settings of
     1200+            # usrsctp.gyp.
     1201+            '<(DEPTH)/third_party/usrsctp/usrsctplib',
     1202+          ],
     1203+          'dependencies': [
     1204+            '<(DEPTH)/third_party/usrsctp/usrsctp.gyp:usrsctplib',
     1205+          ],
     1206+        }],
     1207+      ],
     1208+    },  # target rtc_media_not
     1209+    {
     1210       'target_name': 'rtc_media',
     1211       'type': 'static_library',
     1212       'dependencies': [
     1213diff --git a/webrtc/pc/channelmanager.cc b/webrtc/pc/channelmanager.cc
     1214index 56dd135..06f3892 100644
     1215--- a/webrtc/pc/channelmanager.cc
     1216+++ b/webrtc/pc/channelmanager.cc
     1217@@ -153,6 +153,8 @@ bool ChannelManager::Init() {
     1218         rtc::Bind(&rtc::Thread::SetAllowBlockingCalls, network_thread_, false));
     1219   }
     1220 
     1221+  #ifdef HAVE_NOT
     1222+
     1223   initialized_ = worker_thread_->Invoke<bool>(
     1224       Bind(&ChannelManager::InitMediaEngine_w, this));
     1225   ASSERT(initialized_);
     1226@@ -168,6 +170,10 @@ bool ChannelManager::Init() {
     1227                     << audio_output_volume_;
     1228   }
     1229 
     1230+  #else
     1231+  initialized_ = true;
     1232+  #endif  // HAVE_NOT
     1233+
     1234   return initialized_;
     1235 }
     1236 
     1237diff --git a/webrtc/pc/mediasession.cc b/webrtc/pc/mediasession.cc
     1238index 0fa20d8..f57471a 100644
     1239--- a/webrtc/pc/mediasession.cc
     1240+++ b/webrtc/pc/mediasession.cc
     1241@@ -1234,11 +1234,13 @@ MediaSessionDescriptionFactory::MediaSessionDescriptionFactory(
     1242     : secure_(SEC_DISABLED),
     1243       add_legacy_(true),
     1244       transport_desc_factory_(transport_desc_factory) {
     1245+  #ifdef HAVE_NOT
     1246   channel_manager->GetSupportedAudioCodecs(&audio_codecs_);
     1247   channel_manager->GetSupportedAudioRtpHeaderExtensions(&audio_rtp_extensions_);
     1248   channel_manager->GetSupportedVideoCodecs(&video_codecs_);
     1249   channel_manager->GetSupportedVideoRtpHeaderExtensions(&video_rtp_extensions_);
     1250   channel_manager->GetSupportedDataCodecs(&data_codecs_);
     1251+  #endif  // HAVE_NOT
     1252 }
     1253 
     1254 SessionDescription* MediaSessionDescriptionFactory::CreateOffer(
     1255diff --git a/webrtc/pc/pc.gyp b/webrtc/pc/pc.gyp
     1256index 25ebc5d..59330c1 100755
     1257--- a/webrtc/pc/pc.gyp
     1258+++ b/webrtc/pc/pc.gyp
     1259@@ -21,7 +21,7 @@
     1260       'type': 'static_library',
     1261       'dependencies': [
     1262         '<(webrtc_root)/base/base.gyp:rtc_base',
     1263-        '<(webrtc_root)/media/media.gyp:rtc_media',
     1264+        # '<(webrtc_root)/media/media.gyp:rtc_media',
     1265       ],
     1266       'conditions': [
     1267         ['build_libsrtp==1', {
     1268diff --git a/webrtc/webrtc.gyp b/webrtc/webrtc.gyp
     1269index 793bf96..51fe339 100644
     1270--- a/webrtc/webrtc.gyp
     1271+++ b/webrtc/webrtc.gyp
     1272@@ -35,7 +35,7 @@
     1273         ],
     1274       },
     1275     }],
     1276-    ['build_with_chromium==0 and'
     1277+    ['build_with_chromium==0 and build_have_not==1 and'
     1278      '(OS=="ios" or (OS=="mac" and mac_deployment_target=="10.7"))', {
     1279       # TODO(kjellander): Move this to webrtc_all_dependencies once all of talk/
     1280       # has been moved to webrtc/. It can't be processed by Chromium since the
     1281--
     12822.9.2
     1283
  • gitian/versions

    diff --git a/gitian/versions b/gitian/versions
    index ea305cc..d7aa3c9 100755
    a b OBFS4_TAG=obfs4proxy-0.0.5 
    4343NOTOFONTS_TAG=720e34851382ee3c1ef024d8dffb68ffbfb234c2
    4444DEPOT_TOOLS_TAG=28216cd14b44716db5c83634afbdc6e90492652b
    4545WEBRTC_TAG=f33698296719f956497d2dbff81b5080864a8804 # https://chromium.googlesource.com/external/webrtc.git/+/refs/branch-heads/52
    46 GO_WEBRTC_TAG=69c5ca70533142494d145b43ef2f46ca94715557
     46GO_WEBRTC_TAG=fe652a477eb8514a5c3851515728dae567f3ebc6
    4747SNOWFLAKE_TAG=0ae71952d2d482f5f2de6855d22c76cc9b212564
    4848UNIURI_TAG=8902c56451e9b58ff940bbe5fec35d5f9c04584a
    4949
  • gitian/versions.alpha

    diff --git a/gitian/versions.alpha b/gitian/versions.alpha
    index a38325a..17d623a 100755
    a b OBFS4_TAG=obfs4proxy-0.0.5 
    4343NOTOFONTS_TAG=720e34851382ee3c1ef024d8dffb68ffbfb234c2
    4444DEPOT_TOOLS_TAG=28216cd14b44716db5c83634afbdc6e90492652b
    4545WEBRTC_TAG=f33698296719f956497d2dbff81b5080864a8804 # https://chromium.googlesource.com/external/webrtc.git/+/refs/branch-heads/52
    46 GO_WEBRTC_TAG=69c5ca70533142494d145b43ef2f46ca94715557
     46GO_WEBRTC_TAG=fe652a477eb8514a5c3851515728dae567f3ebc6
    4747SNOWFLAKE_TAG=0ae71952d2d482f5f2de6855d22c76cc9b212564
    4848UNIURI_TAG=8902c56451e9b58ff940bbe5fec35d5f9c04584a
    4949
  • gitian/versions.beta

    diff --git a/gitian/versions.beta b/gitian/versions.beta
    index 99e1994..2c733fa 100755
    a b MEEK_TAG=0.18 
    3131NOTOFONTS_TAG=720e34851382ee3c1ef024d8dffb68ffbfb234c2
    3232DEPOT_TOOLS_TAG=28216cd14b44716db5c83634afbdc6e90492652b
    3333WEBRTC_TAG=f33698296719f956497d2dbff81b5080864a8804 # https://chromium.googlesource.com/external/webrtc.git/+/refs/branch-heads/52
    34 GO_WEBRTC_TAG=69c5ca70533142494d145b43ef2f46ca94715557
     34GO_WEBRTC_TAG=fe652a477eb8514a5c3851515728dae567f3ebc6
    3535SNOWFLAKE_TAG=0ae71952d2d482f5f2de6855d22c76cc9b212564
    3636UNIURI_TAG=8902c56451e9b58ff940bbe5fec35d5f9c04584a
    3737