Move ScopedFILE to base namespace and scoped_file.h

media/cast/test/sender.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.
 
 // Test application that simulates a cast sender - Data can be either generated
 // or read from a file.
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
+#include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread.h"
 #include "base/time/default_tick_clock.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/encoding_event_subscriber.h"
 #include "media/cast/logging/log_serializer.h"
@@ skipping 339 matching lines @@
 }
 
 net::IPEndPoint CreateUDPAddress(std::string ip_str, int port) {
   net::IPAddressNumber ip_number;
   CHECK(net::ParseIPLiteralToNumber(ip_str, &ip_number));
   return net::IPEndPoint(ip_number, port);
 }
 
 void DumpLoggingData(
     scoped_ptr<media::cast::EncodingEventSubscriber> event_subscriber,
-    file_util::ScopedFILE log_file,
+    base::ScopedFILE log_file,
     bool compress) {
   media::cast::FrameEventMap frame_events;
   media::cast::PacketEventMap packet_events;
   media::cast::proto::LogMetadata log_metadata;
 
   event_subscriber->GetEventsAndReset(
       &log_metadata, &frame_events, &packet_events);
 
   VLOG(0) << "Frame map size: " << frame_events.size();
   VLOG(0) << "Packet map size: " << packet_events.size();
@@ skipping 15 matching lines @@
 
   int ret = fwrite(event_log.get(), 1, event_log_bytes, log_file.get());
   if (ret != event_log_bytes)
     VLOG(0) << "Failed to write logs to file.";
 }
 
 void WriteLogsToFileAndStopSubscribing(
     const scoped_refptr<media::cast::CastEnvironment>& cast_environment,
     scoped_ptr<media::cast::EncodingEventSubscriber> video_event_subscriber,
     scoped_ptr<media::cast::EncodingEventSubscriber> audio_event_subscriber,
-    file_util::ScopedFILE video_log_file,
-    file_util::ScopedFILE audio_log_file,
+    base::ScopedFILE video_log_file,
+    base::ScopedFILE audio_log_file,
     bool compress) {
   // Serialize video events.
   cast_environment->Logging()->RemoveRawEventSubscriber(
       video_event_subscriber.get());
   cast_environment->Logging()->RemoveRawEventSubscriber(
       audio_event_subscriber.get());
 
   VLOG(0) << "Dumping logging data for video stream.";
   DumpLoggingData(
       video_event_subscriber.Pass(), video_log_file.Pass(), compress);
@@ skipping 105 matching lines @@
         media::cast::GetAudioLogFileDestination(compress));
     video_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
         media::cast::VIDEO_EVENT, 10000));
     audio_event_subscriber.reset(new media::cast::EncodingEventSubscriber(
         media::cast::AUDIO_EVENT, 10000));
     cast_environment->Logging()->AddRawEventSubscriber(
         video_event_subscriber.get());
     cast_environment->Logging()->AddRawEventSubscriber(
         audio_event_subscriber.get());
 
-    file_util::ScopedFILE video_log_file(
-        fopen(video_log_file_name.c_str(), "w"));
+    base::ScopedFILE video_log_file(fopen(video_log_file_name.c_str(), "w"));
     if (!video_log_file) {
       VLOG(1) << "Failed to open video log file for writing.";
       exit(-1);
     }
 
-    file_util::ScopedFILE audio_log_file(
-        fopen(audio_log_file_name.c_str(), "w"));
+    base::ScopedFILE audio_log_file(fopen(audio_log_file_name.c_str(), "w"));
     if (!audio_log_file) {
       VLOG(1) << "Failed to open audio log file for writing.";
       exit(-1);
     }
 
     io_message_loop.message_loop_proxy()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&WriteLogsToFileAndStopSubscribing,
                    cast_environment,
                    base::Passed(&video_event_subscriber),
                    base::Passed(&audio_event_subscriber),
                    base::Passed(&video_log_file),
                    base::Passed(&audio_log_file),
                    compress),
         base::TimeDelta::FromSeconds(logging_duration));
   }
 
   test_thread.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&media::cast::SendProcess::SendFrame,
                  base::Unretained(send_process.get())));
 
   io_message_loop.Run();
 
   return 0;
 }