Cleanup: Remove static storage for variables in an unnamed namespace.

media/audio/linux/alsa_output.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.
 //
 // THREAD SAFETY
 //
 // AlsaPcmOutputStream object is *not* thread-safe and should only be used
 // from the audio thread.  We DCHECK on this assumption whenever we can.
 //
 // SEMANTICS OF Close()
@@ skipping 31 matching lines @@
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/linux/alsa_util.h"
 #include "media/audio/linux/alsa_wrapper.h"
 #include "media/audio/linux/audio_manager_linux.h"
 #include "media/base/data_buffer.h"
 #include "media/base/seekable_buffer.h"
 
 namespace {

[Ami GONE FROM CHROMIUM, 2012/01/26 03:51:34]

media/ code actually goes the other way - preferring file-static over anon
namespace.  Would you mind reverting this file from this CL?
(and remove the namespace if you're feeling charitable, or else I'll do it)

[James Hawkins, 2012/01/26 03:53:02]

Why would we use two different styles in the same code base?

[James Hawkins, 2012/01/26 04:13:02]

Removed namespace and added back static per-preference of media/

+
 // Amount of time to wait if we've exhausted the data source.  This is to avoid
 // busy looping.
-static const uint32 kNoDataSleepMilliseconds = 10;
+const uint32 kNoDataSleepMilliseconds = 10;
 
 // Mininum interval between OnMoreData() calls.
 const uint32 kMinIntervalBetweenOnMoreDataCallsInMs = 5;
 
 // According to the linux nanosleep manpage, nanosleep on linux can miss the
 // deadline by up to 10ms because the kernel timeslice is 10ms.  Give a 2x
 // buffer to compensate for the timeslice, and any additional slowdowns.
-static const uint32 kSleepErrorMilliseconds = 20;
+const uint32 kSleepErrorMilliseconds = 20;
 
 // Set to 0 during debugging if you want error messages due to underrun
 // events or other recoverable errors.
 #if defined(NDEBUG)
-static const int kPcmRecoverIsSilent = 1;
+const int kPcmRecoverIsSilent = 1;
 #else
-static const int kPcmRecoverIsSilent = 0;
+const int kPcmRecoverIsSilent = 0;
 #endif
 
 // ALSA is currently limited to 48kHz.
 // TODO(fbarchard): Resample audio from higher frequency to 48000.
-static const int kAlsaMaxSampleRate = 48000;
+const int kAlsaMaxSampleRate = 48000;
 
 // While the "default" device may support multi-channel audio, in Alsa, only
 // the device names surround40, surround41, surround50, etc, have a defined
 // channel mapping according to Lennart:
 //
 // http://0pointer.de/blog/projects/guide-to-sound-apis.html
 //
 // This function makes a best guess at the specific > 2 channel device name
 // based on the number of channels requested.  NULL is returned if no device
 // can be found to match the channel numbers.  In this case, using
 // kDefaultDevice is probably the best bet.
 //
 // A five channel source is assumed to be surround50 instead of surround41
 // (which is also 5 channels).
 //
 // TODO(ajwong): The source data should have enough info to tell us if we want
 // surround41 versus surround51, etc., instead of needing us to guess base don
 // channel number.  Fix API to pass that data down.
-static const char* GuessSpecificDeviceName(uint32 channels) {
+const char* GuessSpecificDeviceName(uint32 channels) {
   switch (channels) {
     case 8:
       return "surround71";
 
     case 7:
       return "surround70";
 
     case 6:
       return "surround51";
 
     case 5:
       return "surround50";
 
     case 4:
       return "surround40";
 
     default:
       return NULL;
   }
 }
 
 // Reorder PCM from AAC layout to Alsa layout.
 // TODO(fbarchard): Switch layout when ffmpeg is updated.
 template<class Format>
-static void Swizzle50Layout(Format* b, uint32 filled) {
+void Swizzle50Layout(Format* b, uint32 filled) {
   static const uint32 kNumSurroundChannels = 5;
   Format aac[kNumSurroundChannels];
   for (uint32 i = 0; i < filled; i += sizeof(aac), b += kNumSurroundChannels) {
     memcpy(aac, b, sizeof(aac));
     b[0] = aac[1];  // L
     b[1] = aac[2];  // R
     b[2] = aac[3];  // Ls
     b[3] = aac[4];  // Rs
     b[4] = aac[0];  // C
   }
 }
 
 template<class Format>
-static void Swizzle51Layout(Format* b, uint32 filled) {
+void Swizzle51Layout(Format* b, uint32 filled) {
   static const uint32 kNumSurroundChannels = 6;
   Format aac[kNumSurroundChannels];
   for (uint32 i = 0; i < filled; i += sizeof(aac), b += kNumSurroundChannels) {
     memcpy(aac, b, sizeof(aac));
     b[0] = aac[1];  // L
     b[1] = aac[2];  // R
     b[2] = aac[3];  // Ls
     b[3] = aac[4];  // Rs
     b[4] = aac[0];  // C
     b[5] = aac[5];  // LFE
   }
 }
-}  // end namespace
+
+}  // namespace
 
 std::ostream& operator<<(std::ostream& os,
                          AlsaPcmOutputStream::InternalState state) {
   switch (state) {
     case AlsaPcmOutputStream::kInError:
       os << "kInError";
       break;
     case AlsaPcmOutputStream::kCreated:
       os << "kCreated";
       break;
@@ skipping 682 matching lines @@
   if (source_callback_)
     source_callback_->OnError(this, code);
 }
 
 // Changes the AudioSourceCallback to proxy calls to.  Pass in NULL to
 // release ownership of the currently registered callback.
 void AlsaPcmOutputStream::set_source_callback(AudioSourceCallback* callback) {
   DCHECK(manager_->GetMessageLoop()->BelongsToCurrentThread());
   source_callback_ = callback;
 }