Update MediaStreamTrack::Stop to latest draft.

content/renderer/media/media_stream_impl.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_
 #define CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 81 matching lines @@
   virtual void OnDeviceOpenFailed(int request_id) OVERRIDE;
 
   // RenderViewObserver OVERRIDE
   virtual void FrameDetached(blink::WebFrame* frame) OVERRIDE;
   virtual void FrameWillClose(blink::WebFrame* frame) OVERRIDE;
 
  protected:
   // Called when |source| has been stopped from JavaScript.
   void OnLocalSourceStopped(const blink::WebMediaStreamSource& source);
 
-  // Called when a MediaStream with label |label| has been ordered to stop from
-  // JavaScript. The implementation must stop all sources that are not used by
-  // other MediaStreams.
-  // TODO(perkj): MediaStream::Stop has been deprecated from the spec and all
-  // applications should move to use MediaStreamTrack::Stop instead and this
-  // method be removed.
-  void OnLocalMediaStreamStop(const std::string& label);
-
-  // This function is virtual for test purposes. A test can override this to
+  // These methods are virtual for test purposes. A test can override them to
   // test requesting local media streams. The function notifies WebKit that the
-  // |request| have completed and generated the MediaStream |stream|.
-  virtual void CompleteGetUserMediaRequest(
-      const blink::WebMediaStream& stream,
+  // |request| have completed.
+  virtual void GetUserMediaRequestSucceeded(
+       const blink::WebMediaStream& stream,
+       blink::WebUserMediaRequest* request_info);
+  virtual void GetUserMediaRequestFailed(
       blink::WebUserMediaRequest* request_info,
       content::MediaStreamRequestResult result);
 
+
   // Returns the WebKit representation of a MediaStream given an URL.
   // This is virtual for test purposes.
   virtual blink::WebMediaStream GetMediaStream(const GURL& url);
 
   // Creates a MediaStreamVideoSource object.
   // This is virtual for test purposes.
   virtual MediaStreamVideoSource* CreateVideoSource(
       const StreamDeviceInfo& device,
       const MediaStreamSource::SourceStoppedCallback& stop_callback);
 
@@ skipping 85 matching lines @@
 
   // Callback function triggered when all native versions of the
   // underlying media sources and tracks have been created and started.
   void OnCreateNativeTracksCompleted(
       UserMediaRequestInfo* request,
       content::MediaStreamRequestResult result);
 
   UserMediaRequestInfo* FindUserMediaRequestInfo(int request_id);
   UserMediaRequestInfo* FindUserMediaRequestInfo(
       const blink::WebUserMediaRequest& request);
-  UserMediaRequestInfo* FindUserMediaRequestInfo(const std::string& label);
   void DeleteUserMediaRequestInfo(UserMediaRequestInfo* request);
 
   // Returns the source that use a device with |device.session_id|
   // and |device.device.id|. NULL if such source doesn't exist.
   const blink::WebMediaStreamSource* FindLocalSource(
       const StreamDeviceInfo& device) const;
 
-  // Returns true if |source| exists in |user_media_requests_|
-  bool IsSourceInRequests(const blink::WebMediaStreamSource& source) const;
-
   void StopLocalSource(const blink::WebMediaStreamSource& source,
                        bool notify_dispatcher);
-  // Stops all local sources that don't exist in exist in
-  // |user_media_requests_|.
-  void StopUnreferencedSources(bool notify_dispatcher);
 
   scoped_refptr<WebRtcAudioRenderer> CreateRemoteAudioRenderer(
       webrtc::MediaStreamInterface* stream, int render_frame_id);
   scoped_refptr<WebRtcLocalAudioRenderer> CreateLocalAudioRenderer(
       const blink::WebMediaStreamTrack& audio_track,
       int render_frame_id);
 
   // Returns a valid session id if a single capture device is currently open
   // (and then the matching session_id), otherwise -1.
   // This is used to pass on a session id to a webrtc audio renderer (either
   // local or remote), so that audio will be rendered to a matching output
   // device, should one exist.
   // Note that if there are more than one open capture devices the function
   // will not be able to pick an appropriate device and return false.
   bool GetAuthorizedDeviceInfoForAudioRenderer(
       int* session_id, int* output_sample_rate, int* output_buffer_size);
 
   // Weak ref to a MediaStreamDependencyFactory, owned by the RenderThread.
   // It's valid for the lifetime of RenderThread.
   MediaStreamDependencyFactory* dependency_factory_;
 
   // media_stream_dispatcher_ is a weak reference, owned by RenderView. It's
   // valid for the lifetime of RenderView.
   MediaStreamDispatcher* media_stream_dispatcher_;
 
+  LocalStreamSources local_sources_;
+
   UserMediaRequests user_media_requests_;
 
-  LocalStreamSources local_sources_;
-
   DISALLOW_COPY_AND_ASSIGN(MediaStreamImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_MEDIA_STREAM_IMPL_H_