Cleaning up src/media to be consistent with static versus anonymous namespaces.

media/filters/decoder_base_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 <vector>
 
 #include "media/base/mock_callback.h"
 #include "media/base/mock_filters.h"
 #include "media/base/mock_task.h"
 #include "media/base/pipeline.h"
 #include "media/filters/decoder_base.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::NotNull;
 using ::testing::StrictMock;
 using ::testing::WithArg;
 
 namespace media {
 
 class GTEST_TEST_CLASS_NAME_(DecoderBaseTest, FlowControl);
 
-}  // namespace media
-
-namespace {
-
-class MockDecoderOutput : public media::StreamSample {
+class MockDecoderOutput : public StreamSample {
  public:
   MOCK_CONST_METHOD0(IsEndOfStream, bool());
 };
 
-class MockBuffer : public media::Buffer {
+class MockBuffer : public Buffer {
  public:
   MockBuffer() {}
   virtual ~MockBuffer() {}
   MOCK_CONST_METHOD0(GetData, const uint8*());
   MOCK_CONST_METHOD0(GetDataSize, size_t());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBuffer);
 };
 
-class MockDecoder : public media::Filter {
+class MockDecoder : public Filter {
  public:
   typedef Callback1<scoped_refptr<MockDecoderOutput> >::Type
       ConsumeAudioSamplesCallback;
   void set_consume_audio_samples_callback(
       ConsumeAudioSamplesCallback* callback) {
     consume_audio_samples_callback_.reset(callback);
   }
   ConsumeAudioSamplesCallback* consume_audio_samples_callback() {
     return consume_audio_samples_callback_.get();
   }
   scoped_ptr<ConsumeAudioSamplesCallback> consume_audio_samples_callback_;
 };
 
 class MockDecoderCallback {
  public:
   MOCK_METHOD1(OnReadComplete, void(scoped_refptr<MockDecoderOutput> output));
 };
 
-class MockDecoderImpl : public media::DecoderBase<
+class MockDecoderImpl : public DecoderBase<
   MockDecoder, MockDecoderOutput> {
  public:
   explicit MockDecoderImpl(MessageLoop* message_loop)
-      : media::DecoderBase<MockDecoder, MockDecoderOutput>(message_loop) {
-    media_format_.SetAsString(media::MediaFormat::kMimeType, "mock");
+      : DecoderBase<MockDecoder, MockDecoderOutput>(message_loop) {
+    media_format_.SetAsString(MediaFormat::kMimeType, "mock");
   }
 
   virtual ~MockDecoderImpl() {}
 
   // DecoderBase Implementations.
   MOCK_METHOD3(DoInitialize,
-               void(media::DemuxerStream* demuxer_stream,
+               void(DemuxerStream* demuxer_stream,
                     bool* success,
                     Task* done_cb));
   MOCK_METHOD1(DoStop, void(Task* done_cb));
   MOCK_METHOD2(DoSeek, void(base::TimeDelta time, Task* done_cb));
-  MOCK_METHOD1(DoDecode, void(media::Buffer* input));
+  MOCK_METHOD1(DoDecode, void(Buffer* input));
 
  private:
-  FRIEND_TEST(media::DecoderBaseTest, FlowControl);
+  FRIEND_TEST(DecoderBaseTest, FlowControl);
 
   DISALLOW_COPY_AND_ASSIGN(MockDecoderImpl);
 };
 
-}  // namespace
-
-namespace media {
-
 ACTION(Initialize) {
   AutoTaskRunner done_runner(arg2);
   *arg1 = true;
 }
 
 ACTION_P(SaveDecodeRequest, list) {
   scoped_refptr<Buffer> buffer(arg0);
   list->push_back(buffer);
 }
 
@@ skipping 58 matching lines @@
   message_loop.RunAllPending();
 
   // Stop.
   EXPECT_CALL(*decoder, DoStop(_))
       .WillOnce(WithArg<0>(InvokeRunnable()));
   decoder->Stop(NewExpectedCallback());
   message_loop.RunAllPending();
 }
 
 }  // namespace media