Remove using directives ("using namespace x") from media/.

Bug: 82078
Change-Id: Id055fb1600ada645c1782cddd48348e687aa9245
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1815573
Commit-Queue: Thomas Guilbert <tguilbert@chromium.org>
Reviewed-by: Thomas Guilbert <tguilbert@chromium.org>
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#698543}

media/filters/vpx_video_decoder_fuzzertest.cc

@@ -19,11 +19,9 @@
 #include "media/base/media_util.h"
 #include "media/filters/vpx_video_decoder.h"
 
-using namespace media;
-
 struct Env {
   Env() {
-    InitializeMediaLibrary();
+    media::InitializeMediaLibrary();
     base::CommandLine::Init(0, nullptr);
     logging::SetMinLogLevel(logging::LOG_FATAL);
   }
@@ -32,7 +30,8 @@ struct Env {
   base::MessageLoop message_loop;
 };
 
-void OnDecodeComplete(const base::Closure& quit_closure, DecodeStatus status) {
+void OnDecodeComplete(const base::Closure& quit_closure,
+                      media::DecodeStatus status) {
   quit_closure.Run();
 }
 
@@ -43,7 +42,7 @@ void OnInitDone(const base::Closure& quit_closure,
   quit_closure.Run();
 }
 
-void OnOutputComplete(scoped_refptr<VideoFrame> frame) {}
+void OnOutputComplete(scoped_refptr<media::VideoFrame> frame) {}
 
 // Entry point for LibFuzzer.
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
@@ -62,41 +61,43 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
 
   // Compute randomized constants. Put all rng() usages here.
   // Use only values that pass DCHECK in VpxVideoDecoder::ConfigureDecoder().
-  VideoCodec codec;
+  media::VideoCodec codec;
 
   bool has_alpha = false;
   if (rng() & 1) {
-    codec = kCodecVP8;
+    codec = media::kCodecVP8;
     // non-Alpha VP8 decoding isn't supported by VpxVideoDecoder on Linux.
     has_alpha = true;
   } else {
-    codec = kCodecVP9;
+    codec = media::kCodecVP9;
     has_alpha = rng() & 1;
   }
 
-  auto profile =
-      static_cast<VideoCodecProfile>(rng() % VIDEO_CODEC_PROFILE_MAX);
+  auto profile = static_cast<media::VideoCodecProfile>(
+      rng() % media::VIDEO_CODEC_PROFILE_MAX);
   auto color_space =
-      VideoColorSpace(rng() % 256, rng() % 256, rng() % 256,
-                      (rng() & 1) ? gfx::ColorSpace::RangeID::LIMITED
-                                  : gfx::ColorSpace::RangeID::FULL);
-  auto rotation = static_cast<VideoRotation>(rng() % VIDEO_ROTATION_MAX);
+      media::VideoColorSpace(rng() % 256, rng() % 256, rng() % 256,
+                             (rng() & 1) ? gfx::ColorSpace::RangeID::LIMITED
+                                         : gfx::ColorSpace::RangeID::FULL);
+  auto rotation =
+      static_cast<media::VideoRotation>(rng() % media::VIDEO_ROTATION_MAX);
   auto coded_size = gfx::Size(1 + (rng() % 127), 1 + (rng() % 127));
   auto visible_rect = gfx::Rect(coded_size);
   auto natural_size = gfx::Size(1 + (rng() % 127), 1 + (rng() % 127));
   uint8_t reflection = rng() % 4;
 
-  VideoDecoderConfig config(
+  media::VideoDecoderConfig config(
       codec, profile,
-      has_alpha ? VideoDecoderConfig::AlphaMode::kHasAlpha
-                : VideoDecoderConfig::AlphaMode::kIsOpaque,
-      color_space, VideoTransformation(rotation, reflection), coded_size,
-      visible_rect, natural_size, EmptyExtraData(), Unencrypted());
+      has_alpha ? media::VideoDecoderConfig::AlphaMode::kHasAlpha
+                : media::VideoDecoderConfig::AlphaMode::kIsOpaque,
+      color_space, media::VideoTransformation(rotation, reflection), coded_size,
+      visible_rect, natural_size, media::EmptyExtraData(),
+      media::Unencrypted());
 
   if (!config.IsValidConfig())
     return 0;
 
-  VpxVideoDecoder decoder;
+  media::VpxVideoDecoder decoder;
 
   {
     base::RunLoop run_loop;
@@ -112,7 +113,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
 
   {
     base::RunLoop run_loop;
-    auto buffer = DecoderBuffer::CopyFrom(data, size);
+    auto buffer = media::DecoderBuffer::CopyFrom(data, size);
     decoder.Decode(buffer,
                    base::Bind(&OnDecodeComplete, run_loop.QuitClosure()));
     run_loop.Run();

media/midi/midi_manager_winrt.cc

@@ -40,16 +40,19 @@ namespace midi {
 namespace {
 
 namespace WRL = Microsoft::WRL;
+namespace Win = ABI::Windows;
 
-using namespace ABI::Windows::Devices::Enumeration;
-using namespace ABI::Windows::Devices::Midi;
-using namespace ABI::Windows::Foundation;
-using namespace ABI::Windows::Storage::Streams;
-
-using base::win::ScopedHString;
 using base::win::GetActivationFactory;
+using base::win::ScopedHString;
 using mojom::PortState;
 using mojom::Result;
+using Win::Devices::Enumeration::DeviceInformationUpdate;
+using Win::Devices::Enumeration::DeviceWatcher;
+using Win::Devices::Enumeration::IDeviceInformation;
+using Win::Devices::Enumeration::IDeviceInformationUpdate;
+using Win::Devices::Enumeration::IDeviceWatcher;
+using Win::Foundation::IAsyncOperation;
+using Win::Foundation::ITypedEventHandler;
 
 enum {
   kDefaultTaskRunner = TaskService::kDefaultRunnerId,
@@ -105,9 +108,10 @@ std::string GetNameString(IDeviceInformation* info) {
 // Checks if given DeviceInformation represent a Microsoft GS Wavetable Synth
 // instance.
 bool IsMicrosoftSynthesizer(IDeviceInformation* info) {
-  WRL::ComPtr<IMidiSynthesizerStatics> midi_synthesizer_statics;
+  WRL::ComPtr<Win::Devices::Midi::IMidiSynthesizerStatics>
+      midi_synthesizer_statics;
   HRESULT hr =
-      GetActivationFactory<IMidiSynthesizerStatics,
+      GetActivationFactory<Win::Devices::Midi::IMidiSynthesizerStatics,
                            RuntimeClass_Windows_Devices_Midi_MidiSynthesizer>(
           &midi_synthesizer_statics);
   if (FAILED(hr)) {
@@ -243,9 +247,10 @@ class MidiManagerWinrt::MidiPortManager {
       return false;
     }
 
-    WRL::ComPtr<IDeviceInformationStatics> dev_info_statics;
+    WRL::ComPtr<Win::Devices::Enumeration::IDeviceInformationStatics>
+        dev_info_statics;
     hr = GetActivationFactory<
-        IDeviceInformationStatics,
+        Win::Devices::Enumeration::IDeviceInformationStatics,
         RuntimeClass_Windows_Devices_Enumeration_DeviceInformation>(
         &dev_info_statics);
     if (FAILED(hr)) {
@@ -269,7 +274,8 @@ class MidiManagerWinrt::MidiPortManager {
     TaskService* task_service = midi_service_->task_service();
 
     hr = watcher_->add_Added(
-        WRL::Callback<ITypedEventHandler<DeviceWatcher*, DeviceInformation*>>(
+        WRL::Callback<ITypedEventHandler<
+            DeviceWatcher*, Win::Devices::Enumeration::DeviceInformation*>>(
             [port_manager, task_service](IDeviceWatcher* watcher,
                                          IDeviceInformation* info) {
               if (!info) {
@@ -475,7 +481,8 @@ class MidiManagerWinrt::MidiPortManager {
     TaskService* task_service = midi_service_->task_service();
 
     hr = async_op->put_Completed(
-        WRL::Callback<IAsyncOperationCompletedHandler<RuntimeType*>>(
+        WRL::Callback<
+            Win::Foundation::IAsyncOperationCompletedHandler<RuntimeType*>>(
             [port_manager, task_service](
                 IAsyncOperation<RuntimeType*>* async_op, AsyncStatus status) {
               // A reference to |async_op| is kept in |async_ops_|, safe to pass
@@ -633,9 +640,9 @@ class MidiManagerWinrt::MidiPortManager {
 };
 
 class MidiManagerWinrt::MidiInPortManager final
-    : public MidiPortManager<IMidiInPort,
-                             MidiInPort,
-                             IMidiInPortStatics,
+    : public MidiPortManager<Win::Devices::Midi::IMidiInPort,
+                             Win::Devices::Midi::MidiInPort,
+                             Win::Devices::Midi::IMidiInPortStatics,
                              RuntimeClass_Windows_Devices_Midi_MidiInPort> {
  public:
   MidiInPortManager(MidiManagerWinrt* midi_manager)
@@ -643,7 +650,7 @@ class MidiManagerWinrt::MidiInPortManager final
 
  private:
   // MidiPortManager overrides:
-  bool RegisterOnMessageReceived(IMidiInPort* handle,
+  bool RegisterOnMessageReceived(Win::Devices::Midi::IMidiInPort* handle,
                                  EventRegistrationToken* p_token) override {
     DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner));
 
@@ -651,22 +658,24 @@ class MidiManagerWinrt::MidiInPortManager final
     TaskService* task_service = midi_service_->task_service();
 
     HRESULT hr = handle->add_MessageReceived(
-        WRL::Callback<
-            ITypedEventHandler<MidiInPort*, MidiMessageReceivedEventArgs*>>(
-            [port_manager, task_service](IMidiInPort* handle,
-                                         IMidiMessageReceivedEventArgs* args) {
+        WRL::Callback<ITypedEventHandler<
+            Win::Devices::Midi::MidiInPort*,
+            Win::Devices::Midi::MidiMessageReceivedEventArgs*>>(
+            [port_manager, task_service](
+                Win::Devices::Midi::IMidiInPort* handle,
+                Win::Devices::Midi::IMidiMessageReceivedEventArgs* args) {
               const base::TimeTicks now = base::TimeTicks::Now();
 
               std::string dev_id = GetDeviceIdString(handle);
 
-              WRL::ComPtr<IMidiMessage> message;
+              WRL::ComPtr<Win::Devices::Midi::IMidiMessage> message;
               HRESULT hr = args->get_Message(message.GetAddressOf());
               if (FAILED(hr)) {
                 VLOG(1) << "get_Message failed: " << PrintHr(hr);
                 return hr;
               }
 
-              WRL::ComPtr<IBuffer> buffer;
+              WRL::ComPtr<Win::Storage::Streams::IBuffer> buffer;
               hr = message->get_RawData(buffer.GetAddressOf());
               if (FAILED(hr)) {
                 VLOG(1) << "get_RawData failed: " << PrintHr(hr);
@@ -701,7 +710,8 @@ class MidiManagerWinrt::MidiInPortManager final
     return true;
   }
 
-  void RemovePortEventHandlers(MidiPort<IMidiInPort>* port) override {
+  void RemovePortEventHandlers(
+      MidiPort<Win::Devices::Midi::IMidiInPort>* port) override {
     if (!(port->handle &&
           port->token_MessageReceived.value != kInvalidTokenValue))
       return;
@@ -726,7 +736,7 @@ class MidiManagerWinrt::MidiInPortManager final
                          base::TimeTicks time) {
     DCHECK(midi_service_->task_service()->IsOnTaskRunner(kComTaskRunner));
 
-    MidiPort<IMidiInPort>* port = GetPortByDeviceId(dev_id);
+    MidiPort<Win::Devices::Midi::IMidiInPort>* port = GetPortByDeviceId(dev_id);
     CHECK(port);
 
     midi_manager_->ReceiveMidiData(port->index, &data[0], data.size(), time);
@@ -736,9 +746,9 @@ class MidiManagerWinrt::MidiInPortManager final
 };
 
 class MidiManagerWinrt::MidiOutPortManager final
-    : public MidiPortManager<IMidiOutPort,
-                             IMidiOutPort,
-                             IMidiOutPortStatics,
+    : public MidiPortManager<Win::Devices::Midi::IMidiOutPort,
+                             Win::Devices::Midi::IMidiOutPort,
+                             Win::Devices::Midi::IMidiOutPortStatics,
                              RuntimeClass_Windows_Devices_Midi_MidiOutPort> {
  public:
   MidiOutPortManager(MidiManagerWinrt* midi_manager)
@@ -849,13 +859,14 @@ void MidiManagerWinrt::SendOnComRunner(uint32_t port_index,
   DCHECK(service()->task_service()->IsOnTaskRunner(kComTaskRunner));
 
   base::AutoLock auto_lock(lazy_init_member_lock_);
-  MidiPort<IMidiOutPort>* port = port_manager_out_->GetPortByIndex(port_index);
+  MidiPort<Win::Devices::Midi::IMidiOutPort>* port =
+      port_manager_out_->GetPortByIndex(port_index);
   if (!(port && port->handle)) {
     VLOG(1) << "Port not available: " << port_index;
     return;
   }
 
-  WRL::ComPtr<IBuffer> buffer;
+  WRL::ComPtr<Win::Storage::Streams::IBuffer> buffer;
   HRESULT hr = base::win::CreateIBufferFromData(
       data.data(), static_cast<UINT32>(data.size()), &buffer);
   if (FAILED(hr)) {

media/muxers/webm_muxer_fuzzertest.cc

@@ -18,14 +18,14 @@
 #include "media/base/video_frame.h"
 #include "media/muxers/webm_muxer.h"
 
-using namespace media;
-
 // Min and max number of encodec video/audio packets to send in the WebmMuxer.
 const int kMinNumIterations = 1;
 const int kMaxNumIterations = 10;
 
-static const int kSupportedVideoCodecs[] = {kCodecVP8, kCodecVP9, kCodecH264};
-static const int kSupportedAudioCodecs[] = {kCodecOpus, kCodecPCM};
+static const int kSupportedVideoCodecs[] = {media::kCodecVP8, media::kCodecVP9,
+                                            media::kCodecH264};
+static const int kSupportedAudioCodecs[] = {media::kCodecOpus,
+                                            media::kCodecPCM};
 
 static const int kSampleRatesInKHz[] = {48, 24, 16, 12, 8};
 
@@ -54,12 +54,12 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   }
 
   for (const auto& input_type : kVideoAudioInputTypes) {
-    const auto video_codec = static_cast<VideoCodec>(
+    const auto video_codec = static_cast<media::VideoCodec>(
         kSupportedVideoCodecs[rng() % base::size(kSupportedVideoCodecs)]);
-    const auto audio_codec = static_cast<AudioCodec>(
+    const auto audio_codec = static_cast<media::AudioCodec>(
         kSupportedAudioCodecs[rng() % base::size(kSupportedAudioCodecs)]);
-    WebmMuxer muxer(video_codec, audio_codec, input_type.has_video,
-                    input_type.has_audio, base::Bind(&OnWriteCallback));
+    media::WebmMuxer muxer(video_codec, audio_codec, input_type.has_video,
+                           input_type.has_audio, base::Bind(&OnWriteCallback));
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
 
@@ -68,23 +68,25 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
       if (input_type.has_video) {
         // VideoFrames cannot be arbitrarily small.
         const auto visible_rect = gfx::Size(16 + rng() % 128, 16 + rng() % 128);
-        const auto video_frame = VideoFrame::CreateBlackFrame(visible_rect);
+        const auto video_frame =
+            media::VideoFrame::CreateBlackFrame(visible_rect);
         const auto is_key_frame = rng() % 2;
         const auto has_alpha_frame = rng() % 4;
-        muxer.OnEncodedVideo(WebmMuxer::VideoParameters(video_frame), str,
-                             has_alpha_frame ? str : std::string(),
+        muxer.OnEncodedVideo(media::WebmMuxer::VideoParameters(video_frame),
+                             str, has_alpha_frame ? str : std::string(),
                              base::TimeTicks(), is_key_frame);
         base::RunLoop run_loop;
         run_loop.RunUntilIdle();
       }
 
       if (input_type.has_audio) {
-        const ChannelLayout layout = rng() % 2 ? media::CHANNEL_LAYOUT_STEREO
-                                               : media::CHANNEL_LAYOUT_MONO;
+        const media::ChannelLayout layout = rng() % 2
+                                                ? media::CHANNEL_LAYOUT_STEREO
+                                                : media::CHANNEL_LAYOUT_MONO;
         const int sample_rate =
             kSampleRatesInKHz[rng() % base::size(kSampleRatesInKHz)];
 
-        const AudioParameters params(
+        const media::AudioParameters params(
             media::AudioParameters::AUDIO_PCM_LOW_LATENCY, layout, sample_rate,
             60 * sample_rate);
         muxer.OnEncodedAudio(params, str, base::TimeTicks());