Protect access Pipeline::renderer_ with a lock.

media/base/pipeline.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 "media/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 140 matching lines @@
   volume_ = volume;
   if (running_) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &Pipeline::VolumeChangedTask, weak_factory_.GetWeakPtr(), volume));
   }
 }
 
 TimeDelta Pipeline::GetMediaTime() const {
+  base::AutoLock auto_lock(lock_);
   if (!renderer_)
     return TimeDelta();
 
   TimeDelta media_time = renderer_->GetMediaTime();
-
-  base::AutoLock auto_lock(lock_);
   return std::min(media_time, duration_);
 }
 
 Ranges<TimeDelta> Pipeline::GetBufferedTimeRanges() const {
   base::AutoLock auto_lock(lock_);
   return buffered_time_ranges_;
 }
 
 TimeDelta Pipeline::GetMediaDuration() const {
   base::AutoLock auto_lock(lock_);
@@ skipping 222 matching lines @@
       &Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp));
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoStop(const PipelineStatusCB& done_cb) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
 
-  renderer_.reset();
+  {
+    base::AutoLock auto_lock(lock_);
+    renderer_.reset();
+  }
   text_renderer_.reset();
 
   if (demuxer_) {
     demuxer_->Stop();
     demuxer_ = NULL;
   }
 
   task_runner_->PostTask(FROM_HERE, base::Bind(done_cb, PIPELINE_OK));
 }
 
@@ skipping 243 matching lines @@
 void Pipeline::InitializeDemuxer(const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   demuxer_->Initialize(this, done_cb, text_renderer_);
 }
 
 void Pipeline::InitializeRenderer(const base::Closure& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!demuxer_->GetStream(DemuxerStream::AUDIO) &&
       !demuxer_->GetStream(DemuxerStream::VIDEO)) {
-    renderer_.reset();
+    {
+      base::AutoLock auto_lock(lock_);
+      renderer_.reset();
+    }
     OnError(PIPELINE_ERROR_COULD_NOT_RENDER);
     return;
   }
 
   base::WeakPtr<Pipeline> weak_this = weak_factory_.GetWeakPtr();
   renderer_->Initialize(
       done_cb,
       base::Bind(&Pipeline::OnUpdateStatistics, weak_this),
       base::Bind(&Pipeline::OnRendererEnded, weak_this),
       base::Bind(&Pipeline::OnError, weak_this),
@@ skipping 15 matching lines @@
   metadata_cb_.Run(metadata);
 }
 
 void Pipeline::BufferingStateChanged(BufferingState new_buffering_state) {
   DVLOG(1) << __FUNCTION__ << "(" << new_buffering_state << ") ";
   DCHECK(task_runner_->BelongsToCurrentThread());
   buffering_state_cb_.Run(new_buffering_state);
 }
 
 }  // namespace media