Adding JSEP PeerConnection glue - attempt 2

content/renderer/media/mock_media_stream_dependency_factory.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 "base/logging.h"
 #include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_peer_connection_impl.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 #include "third_party/libjingle/source/talk/base/scoped_ref_ptr.h"
 
@@ skipping 105 matching lines @@
 }
 
 void MockLocalVideoTrack::RegisterObserver(ObserverInterface* observer) {
   NOTIMPLEMENTED();
 }
 
 void MockLocalVideoTrack::UnregisterObserver(ObserverInterface* observer) {
   NOTIMPLEMENTED();
 }
 
+class MockSessionDescription : public SessionDescriptionInterface {
+ public:
+  MockSessionDescription(const std::string& sdp)
+      : sdp_(sdp) {
+  }
+  virtual ~MockSessionDescription() {}
+  virtual const cricket::SessionDescription* description() const OVERRIDE {
+    NOTIMPLEMENTED();
+    return NULL;
+  }
+  virtual bool AddCandidate(const IceCandidateInterface* candidate) OVERRIDE {
+    NOTIMPLEMENTED();
+    return false;
+  }
+  virtual size_t number_of_mediasections() const OVERRIDE {
+    NOTIMPLEMENTED();
+    return 0;
+  }
+  virtual const IceCandidateColletion* candidates(
+      size_t mediasection_index) const OVERRIDE {
+    NOTIMPLEMENTED();
+    return NULL;
+  }
+  virtual bool ToString(std::string* out) const OVERRIDE {
+    *out = sdp_;
+    return true;
+  }
+
+ private:
+  std::string sdp_;
+};
+
+class MockIceCandidate : public IceCandidateInterface {
+ public:
+  MockIceCandidate(const std::string& label, const std::string& sdp)
+      : label_(label),
+        sdp_(sdp) {
+  }
+  virtual ~MockIceCandidate() {}
+  virtual std::string label() const OVERRIDE {
+    return label_;
+  }
+  virtual const cricket::Candidate& candidate() const OVERRIDE {
+    // This function should never be called. It will intentionally crash. The
+    // base class forces us to return a reference.
+    NOTREACHED();
+    cricket::Candidate* candidate = NULL;
+    return *candidate;
+  }
+  virtual bool ToString(std::string* out) const OVERRIDE {
+    *out = sdp_;
+    return true;
+  }
+
+ private:
+  std::string label_;
+  std::string sdp_;
+};
+
 }  // namespace webrtc
 
 MockMediaStreamDependencyFactory::MockMediaStreamDependencyFactory()
     : mock_pc_factory_created_(false) {
 }
 
 MockMediaStreamDependencyFactory::~MockMediaStreamDependencyFactory() {}
 
 bool MockMediaStreamDependencyFactory::CreatePeerConnectionFactory(
     talk_base::Thread* worker_thread,
@@ skipping 11 matching lines @@
 
 bool MockMediaStreamDependencyFactory::PeerConnectionFactoryCreated() {
   return mock_pc_factory_created_;
 }
 
 talk_base::scoped_refptr<webrtc::PeerConnectionInterface>
 MockMediaStreamDependencyFactory::CreatePeerConnection(
     const std::string& config,
     webrtc::PeerConnectionObserver* observer) {
   DCHECK(mock_pc_factory_created_);
-  return new talk_base::RefCountedObject<webrtc::MockPeerConnectionImpl>();
+  return new talk_base::RefCountedObject<webrtc::MockPeerConnectionImpl>(this);
 }
 
 talk_base::scoped_refptr<webrtc::PeerConnectionInterface>
 MockMediaStreamDependencyFactory::CreateRoapPeerConnection(
     const std::string& config,
     webrtc::PeerConnectionObserver* observer) {
   DCHECK(mock_pc_factory_created_);
-  return new talk_base::RefCountedObject<webrtc::MockPeerConnectionImpl>();
+  return new talk_base::RefCountedObject<webrtc::MockPeerConnectionImpl>(this);
 }
 
 talk_base::scoped_refptr<webrtc::LocalMediaStreamInterface>
 MockMediaStreamDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   talk_base::scoped_refptr<webrtc::LocalMediaStreamInterface> stream(
       new talk_base::RefCountedObject<webrtc::MockLocalMediaStream>(label));
   return stream;
 }
 
 talk_base::scoped_refptr<webrtc::LocalVideoTrackInterface>
 MockMediaStreamDependencyFactory::CreateLocalVideoTrack(
     const std::string& label,
     cricket::VideoCapturer* video_device) {
   talk_base::scoped_refptr<webrtc::LocalVideoTrackInterface> stream(
       new talk_base::RefCountedObject<webrtc::MockLocalVideoTrack>(label));
   return stream;
 }
 
 talk_base::scoped_refptr<webrtc::LocalAudioTrackInterface>
 MockMediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& label,
     webrtc::AudioDeviceModule* audio_device) {
   NOTIMPLEMENTED();
   return NULL;
 }
+
+webrtc::SessionDescriptionInterface*
+MockMediaStreamDependencyFactory::CreateSessionDescription(
+    const std::string& sdp) {
+  return new webrtc::MockSessionDescription(sdp);
+}
+
+webrtc::IceCandidateInterface*
+MockMediaStreamDependencyFactory::CreateIceCandidate(
+    const std::string& label,
+    const std::string& sdp) {
+  return new webrtc::MockIceCandidate(label, sdp);
+}