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

media/audio/win/audio_output_win_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 <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/sync_socket.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager.h"
 #include "media/audio/simple_sources.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::Field;
 using ::testing::InSequence;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
 
-namespace {
-
-const wchar_t kAudioFile1_16b_m_16K[]
+static const wchar_t kAudioFile1_16b_m_16K[]
     = L"media\\test\\data\\sweep02_16b_mono_16KHz.raw";
 
 // This class allows to find out if the callbacks are occurring as
 // expected and if any error has been reported.
 class TestSourceBasic : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit TestSourceBasic()
       : callback_count_(0),
         had_error_(0) {
   }
@@ skipping 21 matching lines @@
 
   void set_error(bool error) {
     had_error_ += error ? 1 : 0;
   }
 
  private:
   int callback_count_;
   int had_error_;
 };
 
-bool IsRunningHeadless() {
+static bool IsRunningHeadless() {
   return (0 != ::GetEnvironmentVariableW(L"CHROME_HEADLESS", NULL, 0));
 }
 
-}  // namespace.
-
 const int kNumBuffers = 3;
 // Specializes TestSourceBasic to detect that the AudioStream is using
 // triple buffering correctly.
 class TestSourceTripleBuffer : public TestSourceBasic {
  public:
   TestSourceTripleBuffer() {
     buffer_address_[0] = NULL;
     buffer_address_[1] = NULL;
     buffer_address_[2] = NULL;
   }
@@ skipping 523 matching lines @@
                                  Field(&AudioBuffersState::pending_bytes, 0)))
       .Times(AnyNumber())
       .WillRepeatedly(Return(0));
 
   oas->Start(&source);
   ::Sleep(500);
   oas->Stop();
   oas->Close();
 }
 
-namespace {
 // Simple source that uses a SyncSocket to retrieve the audio data
 // from a potentially remote thread.
 class SyncSocketSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit SyncSocketSource(base::SyncSocket* socket)
       : socket_(socket) {}
 
   ~SyncSocketSource() {
     delete socket_;
   }
@@ skipping 44 matching lines @@
       break;
     if ((times > 0) && (buffers_state.pending_bytes < 1000)) __debugbreak();
     ctx.socket->Send(&buffer[ix], ctx.packet_size);
     ++times;
   }
 
   delete buffer;
   return 0;
 }
 
-}  // namespace
-
 // Test the basic operation of AudioOutputStream used with a SyncSocket.
 // The emphasis is to test low-latency with buffers less than 100ms. With
 // the waveout api it seems not possible to go below 50ms. In this test
 // you should hear a continous 200Hz tone.
 //
 // TODO(cpu): This actually sounds choppy most of the time. Fix it.
 TEST(WinAudioTest, SyncSocketBasic) {
   if (IsRunningHeadless())
     return;
 
@@ skipping 28 matching lines @@
 
   oas->Start(&source);
 
   ::WaitForSingleObject(thread, INFINITE);
   ::CloseHandle(thread);
   delete sockets[1];
 
   oas->Stop();
   oas->Close();
 }