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

media/tools/scaler_bench/scaler_bench.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.
 
 // This tool can be used to measure performace of video frame scaling
 // code. It times performance of the scaler with and without filtering.
 // It also measures performance of the Skia scaler for comparison.
 
 #include <iostream>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/scoped_vector.h"
 #include "base/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
 #include "skia/ext/platform_canvas.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using media::VideoFrame;
 
-namespace {
+static int source_width = 1280;
+static int source_height = 720;
+static int dest_width = 1366;
+static int dest_height = 768;
+static int num_frames = 500;
+static int num_buffers = 50;
 
-int source_width = 1280;
-int source_height = 720;
-int dest_width = 1366;
-int dest_height = 768;
-int num_frames = 500;
-int num_buffers = 50;
-
-double BenchmarkSkia() {
+static double BenchmarkSkia() {
   std::vector<scoped_refptr<VideoFrame> > source_frames;
   ScopedVector<SkBitmap> dest_frames;
   for (int i = 0; i < num_buffers; i++) {
     scoped_refptr<VideoFrame> source_frame;
     VideoFrame::CreateBlackFrame(source_width, source_height, &source_frame);
     source_frames.push_back(source_frame);
 
     SkBitmap* bitmap = new SkBitmap();
     bitmap->setConfig(SkBitmap::kARGB_8888_Config,
                       dest_width, dest_height);
@@ skipping 35 matching lines @@
                     SkIntToScalar(dest_height) /
                     SkIntToScalar(source_height));
     SkPaint paint;
     paint.setFlags(SkPaint::kFilterBitmap_Flag);
     canvas.drawBitmapMatrix(bitmap, matrix, &paint);
   }
   TimeTicks end = TimeTicks::HighResNow();
   return static_cast<double>((end - start).InMilliseconds()) / num_frames;
 }
 
-double BenchmarkRGBToYUV() {
+static double BenchmarkRGBToYUV() {
   int rgb_stride = source_width * 4;
   scoped_array<uint8> rgb_frame(new uint8[rgb_stride * source_height]);
 
   int y_stride = source_width;
   int uv_stride = source_width / 2;
   scoped_array<uint8> y_plane(new uint8[y_stride * source_height]);
   scoped_array<uint8> u_plane(new uint8[uv_stride * source_height / 2]);
   scoped_array<uint8> v_plane(new uint8[uv_stride * source_height / 2]);
 
   TimeTicks start = TimeTicks::HighResNow();
 
   for (int i = 0; i < num_frames; ++i) {
     media::ConvertRGB32ToYUV(rgb_frame.get(),
                              y_plane.get(),
                              u_plane.get(),
                              v_plane.get(),
                              source_width,
                              source_height,
                              rgb_stride,
                              y_stride,
                              uv_stride);
   }
 
   TimeTicks end = TimeTicks::HighResNow();
   return static_cast<double>((end - start).InMilliseconds()) / num_frames;
 }
 
-double BenchmarkFilter(media::ScaleFilter filter) {
+static double BenchmarkFilter(media::ScaleFilter filter) {
   std::vector<scoped_refptr<VideoFrame> > source_frames;
   std::vector<scoped_refptr<VideoFrame> > dest_frames;
 
   for (int i = 0; i < num_buffers; i++) {
     scoped_refptr<VideoFrame> source_frame;
     VideoFrame::CreateBlackFrame(source_width, source_height, &source_frame);
     source_frames.push_back(source_frame);
 
     scoped_refptr<VideoFrame> dest_frame;
     VideoFrame::CreateFrame(VideoFrame::RGB32,
@@ skipping 22 matching lines @@
                            source_frame->stride(VideoFrame::kUPlane),
                            dest_frame->stride(0),
                            media::YV12,
                            media::ROTATE_0,
                            filter);
   }
   TimeTicks end = TimeTicks::HighResNow();
   return static_cast<double>((end - start).InMilliseconds()) / num_frames;
 }
 
-}  // namespace
-
 int main(int argc, const char** argv) {
   CommandLine::Init(argc, argv);
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
   if (!cmd_line->args().empty()) {
     std::cerr << "Usage: " << argv[0] << " [OPTIONS]\n"
               << "  --frames=N                      "
               << "Number of frames\n"
               << "  --buffers=N                     "
               << "Number of buffers\n"
@@ skipping 62 matching lines @@
             << BenchmarkFilter(media::FILTER_BILINEAR_V)
             << "ms/frame" << std::endl;
   std::cout << "Bilinear Horizontal: "
             << BenchmarkFilter(media::FILTER_BILINEAR_H)
             << "ms/frame" << std::endl;
   std::cout << "Bilinear: " << BenchmarkFilter(media::FILTER_BILINEAR)
             << "ms/frame" << std::endl;
 
   return 0;
 }