Fixes for memory and threading issues in cast

media/cast/audio_sender/audio_encoder_unittest.cc

 // Copyright 2013 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 <sstream>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 72 matching lines @@
     return out.str();
   }
 };
 
 }  // namespace
 
 class AudioEncoderTest : public ::testing::TestWithParam<TestScenario> {
  public:
   AudioEncoderTest() {
     InitializeMediaLibraryForTesting();
-    testing_clock_.Advance(
+    testing_clock_ = new base::SimpleTestTickClock();
+    testing_clock_->Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
   }
 
   virtual void SetUp() {
-    task_runner_ = new test::FakeTaskRunner(&testing_clock_);
-    cast_environment_ = new CastEnvironment(&testing_clock_, task_runner_,
+    task_runner_ = new test::FakeTaskRunner(testing_clock_);
+    cast_environment_ = new CastEnvironment(
+        scoped_ptr<base::TickClock>(testing_clock_).Pass(), task_runner_,
         task_runner_, task_runner_, task_runner_, task_runner_, task_runner_,
         GetDefaultCastSenderLoggingConfig());
   }
 
   virtual ~AudioEncoderTest() {}
 
   void RunTestForCodec(transport::AudioCodec codec) {
     const TestScenario& scenario = GetParam();
     SCOPED_TRACE(::testing::Message()
                  << "Durations: " << scenario.ToString());
 
     CreateObjectsForCodec(codec);
 
-    receiver_->SetRecordedTimeLowerBound(testing_clock_.NowTicks());
+    receiver_->SetRecordedTimeLowerBound(testing_clock_->NowTicks());
     for (size_t i = 0; i < scenario.num_durations; ++i) {
       const base::TimeDelta duration =
           base::TimeDelta::FromMilliseconds(scenario.durations_in_ms[i]);
       receiver_->SetRecordedTimeUpperBound(
-          testing_clock_.NowTicks() + duration);
+          testing_clock_->NowTicks() + duration);
 
       const scoped_ptr<AudioBus> bus(
           audio_bus_factory_->NextAudioBus(duration));
 
       const int last_count = release_callback_count_;
       audio_encoder_->InsertAudio(
-          bus.get(), testing_clock_.NowTicks(),
+          bus.get(), testing_clock_->NowTicks(),
           base::Bind(&AudioEncoderTest::IncrementReleaseCallbackCounter,
                      base::Unretained(this)));
       task_runner_->RunTasks();
       EXPECT_EQ(1, release_callback_count_ - last_count)
           << "Release callback was not invoked once.";
 
-      testing_clock_.Advance(duration);
+      testing_clock_->Advance(duration);
     }
 
     DVLOG(1) << "Received " << receiver_->frames_received()
              << " frames for this test run: " << scenario.ToString();
   }
 
  private:
   void CreateObjectsForCodec(transport::AudioCodec codec) {
     AudioSenderConfig audio_config;
     audio_config.codec = codec;
@@ skipping 13 matching lines @@
         cast_environment_, audio_config,
         base::Bind(&TestEncodedAudioFrameReceiver::FrameEncoded,
                    base::Unretained(receiver_.get())));
     release_callback_count_ = 0;
   }
 
   void IncrementReleaseCallbackCounter() {
     ++release_callback_count_;
   }
 
-  base::SimpleTestTickClock testing_clock_;
+  base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment.
   scoped_refptr<test::FakeTaskRunner> task_runner_;
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
   scoped_ptr<TestEncodedAudioFrameReceiver> receiver_;
   scoped_refptr<AudioEncoder> audio_encoder_;
   scoped_refptr<CastEnvironment> cast_environment_;
   int release_callback_count_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioEncoderTest);
 };
 
@@ skipping 48 matching lines @@
          TestScenario(kManyCalls_3Millis, arraysize(kManyCalls_3Millis)),
          TestScenario(kManyCalls_10Millis, arraysize(kManyCalls_10Millis)),
          TestScenario(kManyCalls_Mixed1, arraysize(kManyCalls_Mixed1)),
          TestScenario(kManyCalls_Mixed2, arraysize(kManyCalls_Mixed2)),
          TestScenario(kManyCalls_Mixed3, arraysize(kManyCalls_Mixed3)),
          TestScenario(kManyCalls_Mixed4, arraysize(kManyCalls_Mixed4)),
          TestScenario(kManyCalls_Mixed5, arraysize(kManyCalls_Mixed5))));
 
 }  // namespace cast
 }  // namespace media