Remove LazyInstance usage from media/

media/cast/test/utility/udp_proxy_main.cc

 // Copyright 2014 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 <stdint.h>
 #include <cstdio>
 #include <cstdlib>
 #include <deque>
 #include <string>
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/cast/test/utility/udp_proxy.h"
 #include "net/base/ip_address.h"
 
 class ByteCounter {
  public:
@@ skipping 33 matching lines @@
 
  private:
   uint64_t bytes_;
   uint64_t packets_;
   std::deque<uint64_t> byte_data_;
   std::deque<uint64_t> packet_data_;
   std::deque<base::TimeTicks> time_data_;
 };
 
 namespace {
+
 struct GlobalCounter {
   base::TimeTicks last_printout;
   ByteCounter in_pipe_input_counter;
   ByteCounter in_pipe_output_counter;
   ByteCounter out_pipe_input_counter;
   ByteCounter out_pipe_output_counter;
 };
+
+GlobalCounter* GetGlobalCounter() {
+  static GlobalCounter* counter = new GlobalCounter();
+  return counter;
+}
+
 }  // namespace
 
-base::LazyInstance<GlobalCounter>::Leaky g_counter =
-    LAZY_INSTANCE_INITIALIZER;
-
 class ByteCounterPipe : public media::cast::test::PacketPipe {
  public:
   ByteCounterPipe(ByteCounter* counter) : counter_(counter) {}
   void Send(std::unique_ptr<media::cast::Packet> packet) final {
     counter_->Increment(packet->size());
     pipe_->Send(std::move(packet));
   }
  private:
   ByteCounter* counter_;
 };
 
 void SetupByteCounters(std::unique_ptr<media::cast::test::PacketPipe>* pipe,
                        ByteCounter* pipe_input_counter,
                        ByteCounter* pipe_output_counter) {
   media::cast::test::PacketPipe* new_pipe =
       new ByteCounterPipe(pipe_input_counter);
   new_pipe->AppendToPipe(std::move(*pipe));
   new_pipe->AppendToPipe(std::unique_ptr<media::cast::test::PacketPipe>(
       new ByteCounterPipe(pipe_output_counter)));
   pipe->reset(new_pipe);
 }
 
 void CheckByteCounters() {
+  GlobalCounter* counter = GetGlobalCounter();
+
   base::TimeTicks now = base::TimeTicks::Now();
-  g_counter.Get().in_pipe_input_counter.push(now);
-  g_counter.Get().in_pipe_output_counter.push(now);
-  g_counter.Get().out_pipe_input_counter.push(now);
-  g_counter.Get().out_pipe_output_counter.push(now);
-  if ((now - g_counter.Get().last_printout).InSeconds() >= 5) {
+  counter->in_pipe_input_counter.push(now);
+  counter->in_pipe_output_counter.push(now);
+  counter->out_pipe_input_counter.push(now);
+  counter->out_pipe_output_counter.push(now);
+  if ((now - counter->last_printout).InSeconds() >= 5) {
     fprintf(stderr, "Sending  : %5.2f / %5.2f mbps %6.2f / %6.2f packets / s\n",
-            g_counter.Get().in_pipe_output_counter.megabits_per_second(),
-            g_counter.Get().in_pipe_input_counter.megabits_per_second(),
-            g_counter.Get().in_pipe_output_counter.packets_per_second(),
-            g_counter.Get().in_pipe_input_counter.packets_per_second());
+            counter->in_pipe_output_counter.megabits_per_second(),
+            counter->in_pipe_input_counter.megabits_per_second(),
+            counter->in_pipe_output_counter.packets_per_second(),
+            counter->in_pipe_input_counter.packets_per_second());
     fprintf(stderr, "Receiving: %5.2f / %5.2f mbps %6.2f / %6.2f packets / s\n",
-            g_counter.Get().out_pipe_output_counter.megabits_per_second(),
-            g_counter.Get().out_pipe_input_counter.megabits_per_second(),
-            g_counter.Get().out_pipe_output_counter.packets_per_second(),
-            g_counter.Get().out_pipe_input_counter.packets_per_second());
+            counter->out_pipe_output_counter.megabits_per_second(),
+            counter->out_pipe_input_counter.megabits_per_second(),
+            counter->out_pipe_output_counter.packets_per_second(),
+            counter->out_pipe_input_counter.packets_per_second());
 
-    g_counter.Get().last_printout = now;
+    counter->last_printout = now;
   }
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CheckByteCounters),
       base::TimeDelta::FromMilliseconds(100));
 }
 
 int main(int argc, char** argv) {
   base::AtExitManager at_exit;
   base::CommandLine::Init(argc, argv);
@@ skipping 49 matching lines @@
     in_pipe = media::cast::test::EvilNetwork();
     out_pipe = media::cast::test::EvilNetwork();
   } else if (network_type == "poisson-wifi") {
     in_pipe = ipp->NewBuffer(128 * 1024);
     out_pipe = ipp->NewBuffer(128 * 1024);
   } else {
     fprintf(stderr, "Unknown network type.\n");
     exit(1);
   }
 
-  SetupByteCounters(&in_pipe, &(g_counter.Get().in_pipe_input_counter),
-                    &(g_counter.Get().in_pipe_output_counter));
-  SetupByteCounters(
-      &out_pipe, &(g_counter.Get().out_pipe_input_counter),
-      &(g_counter.Get().out_pipe_output_counter));
+  GlobalCounter* counter = GetGlobalCounter();
+
+  SetupByteCounters(&in_pipe, &(counter->in_pipe_input_counter),
+                    &(counter->in_pipe_output_counter));
+  SetupByteCounters(&out_pipe, &(counter->out_pipe_input_counter),
+                    &(counter->out_pipe_output_counter));
 
   printf("Press Ctrl-C when done.\n");
   std::unique_ptr<media::cast::test::UDPProxy> proxy(
       media::cast::test::UDPProxy::Create(local_endpoint, remote_endpoint,
                                           std::move(in_pipe),
                                           std::move(out_pipe), NULL));
   base::MessageLoop message_loop;
-  g_counter.Get().last_printout = base::TimeTicks::Now();
+  counter->last_printout = base::TimeTicks::Now();
   CheckByteCounters();
   base::RunLoop().Run();
   return 1;
 }