Snapshot of all changes to get jumbo in blink and content.

content/renderer/media/webrtc/media_stream_track_metrics.cc

 // Copyright 2014 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/webrtc/media_stream_track_metrics.h"
 
 #include <inttypes.h>
 #include <set>
 #include <string>
 
@@ skipping 17 matching lines @@
 IdSet GetTrackIds(const std::vector<rtc::scoped_refptr<T>>& tracks) {
   IdSet track_ids;
   for (const auto& track : tracks)
     track_ids.insert(track->id());
   return track_ids;
 }
 
 // TODO(tommi): Consolidate this and TrackObserver since these implementations
 // are fundamentally achieving the same thing (aside from specific logic inside
 // the OnChanged callbacks).
-class MediaStreamObserver
-    : public base::RefCountedThreadSafe<MediaStreamObserver>,
+class MediaStreamTrackObserver
+    : public base::RefCountedThreadSafe<MediaStreamTrackObserver>,
       public webrtc::ObserverInterface {
  public:
   typedef base::Callback<
       void(const IdSet& audio_track_ids, const IdSet& video_track_ids)>
           OnChangedCallback;
 
-  MediaStreamObserver(
+  MediaStreamTrackObserver(
       const OnChangedCallback& callback,
       const scoped_refptr<base::SingleThreadTaskRunner>& main_thread,
       webrtc::MediaStreamInterface* stream)
       : main_thread_(main_thread), stream_(stream), callback_(callback) {
     signaling_thread_.DetachFromThread();
     stream_->RegisterObserver(this);
   }
 
   const scoped_refptr<webrtc::MediaStreamInterface>& stream() const {
     DCHECK(main_thread_->BelongsToCurrentThread());
     return stream_;
   }
 
   void Unregister() {
     DCHECK(main_thread_->BelongsToCurrentThread());
     callback_.Reset();
     stream_->UnregisterObserver(this);
     stream_ = nullptr;
   }
 
  private:
-  friend class base::RefCountedThreadSafe<MediaStreamObserver>;
-  ~MediaStreamObserver() override {
+  friend class base::RefCountedThreadSafe<MediaStreamTrackObserver>;
+  ~MediaStreamTrackObserver() override {
     DCHECK(!stream_.get()) << "must have been unregistered before deleting";
   }
 
   // webrtc::ObserverInterface implementation.
   void OnChanged() override {
     DCHECK(signaling_thread_.CalledOnValidThread());
     main_thread_->PostTask(FROM_HERE,
-        base::Bind(&MediaStreamObserver::OnChangedOnMainThread, this,
+        base::Bind(&MediaStreamTrackObserver::OnChangedOnMainThread, this,
                    GetTrackIds(stream_->GetAudioTracks()),
                    GetTrackIds(stream_->GetVideoTracks())));
   }
 
   void OnChangedOnMainThread(const IdSet& audio_track_ids,
                              const IdSet& video_track_ids) {
     DCHECK(main_thread_->BelongsToCurrentThread());
     if (!callback_.is_null())
       callback_.Run(audio_track_ids, video_track_ids);
   }
@@ skipping 43 matching lines @@
 
   // False until start/end of lifetime messages have been sent.
   bool has_reported_start_;
   bool has_reported_end_;
 
   // IDs of audio and video tracks in the stream being observed.
   IdSet audio_track_ids_;
   IdSet video_track_ids_;
 
   MediaStreamTrackMetrics::StreamType stream_type_;
-  scoped_refptr<MediaStreamObserver> observer_;
+  scoped_refptr<MediaStreamTrackObserver> observer_;
 
   // Non-owning.
   MediaStreamTrackMetrics* owner_;
   base::ThreadChecker thread_checker_;
 };
 
 namespace {
 
 // Used with std::find_if.
 struct ObserverFinder {
@@ skipping 13 matching lines @@
 
 MediaStreamTrackMetricsObserver::MediaStreamTrackMetricsObserver(
     MediaStreamTrackMetrics::StreamType stream_type,
     MediaStreamInterface* stream,
     MediaStreamTrackMetrics* owner)
     : has_reported_start_(false),
       has_reported_end_(false),
       audio_track_ids_(GetTrackIds(stream->GetAudioTracks())),
       video_track_ids_(GetTrackIds(stream->GetVideoTracks())),
       stream_type_(stream_type),
-      observer_(new MediaStreamObserver(
+      observer_(new MediaStreamTrackObserver(
             base::Bind(&MediaStreamTrackMetricsObserver::OnChanged,
                        base::Unretained(this)),
             base::ThreadTaskRunnerHandle::Get(),
             stream)),
       owner_(owner) {
 }
 
 MediaStreamTrackMetricsObserver::~MediaStreamTrackMetricsObserver() {
   DCHECK(thread_checker_.CalledOnValidThread());
   observer_->Unregister();
@@ skipping 207 matching lines @@
 }
 
 uint64_t MediaStreamTrackMetrics::MakeUniqueId(const std::string& track_id,
                                                StreamType stream_type) {
   return MakeUniqueIdImpl(
       reinterpret_cast<uint64_t>(reinterpret_cast<void*>(this)), track_id,
       stream_type);
 }
 
 }  // namespace content