Cast: Switch EVIL network for bad network in performance test

chrome/browser/extensions/api/cast_streaming/performance_test.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 <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #if defined(OS_MACOSX)
@@ skipping 54 matching lines @@
   kUseGpu              = 1 << 0, // Only execute test if --enable-gpu was given
                                  // on the command line.  This is required for
                                  // tests that run on GPU.
   kDisableVsync        = 1 << 1, // Do not limit framerate to vertical refresh.
                                  // when on GPU, nor to 60hz when not on GPU.
   kSmallWindow         = 1 << 2, // 1 = 800x600, 0 = 2000x1000
   k24fps               = 1 << 3, // use 24 fps video
   k30fps               = 1 << 4, // use 30 fps video
   k60fps               = 1 << 5, // use 60 fps video
   kProxyWifi           = 1 << 6, // Run UDP through UDPProxy wifi profile
-  kProxyEvil           = 1 << 7, // Run UDP through UDPProxy evil profile
+  kProxyBad            = 1 << 7, // Run UDP through UDPProxy bad profile
   kSlowClock           = 1 << 8, // Receiver clock is 10 seconds slow
   kFastClock           = 1 << 9, // Receiver clock is 10 seconds fast
 };
 
 class SkewedTickClock : public base::DefaultTickClock {
  public:
   explicit SkewedTickClock(const base::TimeDelta& delta) : delta_(delta) {
   }
   virtual base::TimeTicks NowTicks() OVERRIDE {
     return DefaultTickClock::NowTicks() + delta_;
@@ skipping 221 matching lines @@
     if (HasFlag(kSmallWindow))
       suffix += "_small";
     if (HasFlag(k24fps))
       suffix += "_24fps";
     if (HasFlag(k30fps))
       suffix += "_30fps";
     if (HasFlag(k60fps))
       suffix += "_60fps";
     if (HasFlag(kProxyWifi))
       suffix += "_wifi";
-    if (HasFlag(kProxyEvil))
-      suffix += "_evil";
+    if (HasFlag(kProxyBad))
+      suffix += "_bad";
     if (HasFlag(kSlowClock))
       suffix += "_slow";
     if (HasFlag(kFastClock))
       suffix += "_fast";
     return suffix;
   }
 
   int getfps() {
     if (HasFlag(k24fps))
       return 24;
@@ skipping 259 matching lines @@
     if (HasFlag(kSlowClock)) {
       delta = base::TimeDelta::FromSeconds(-10);
     }
     scoped_refptr<media::cast::StandaloneCastEnvironment> cast_environment(
         new SkewedCastEnvironment(delta));
     TestPatternReceiver* const receiver =
         new TestPatternReceiver(cast_environment, receiver_end_point);
     receiver->Start();
 
     scoped_ptr<media::cast::test::UDPProxy> udp_proxy;
-    if (HasFlag(kProxyWifi) || HasFlag(kProxyEvil)) {
+    if (HasFlag(kProxyWifi) || HasFlag(kProxyBad)) {
       net::IPEndPoint proxy_end_point = GetFreeLocalPort();
       if (HasFlag(kProxyWifi)) {
         udp_proxy = media::cast::test::UDPProxy::Create(
             proxy_end_point,
             receiver_end_point,
             media::cast::test::WifiNetwork().Pass(),
             media::cast::test::WifiNetwork().Pass(),
             NULL);
-      } else if (HasFlag(kProxyEvil)) {
+      } else if (HasFlag(kProxyBad)) {
         udp_proxy = media::cast::test::UDPProxy::Create(
             proxy_end_point,
             receiver_end_point,
-            media::cast::test::EvilNetwork().Pass(),
-            media::cast::test::EvilNetwork().Pass(),
+            media::cast::test::BadNetwork().Pass(),
+            media::cast::test::BadNetwork().Pass(),
             NULL);
       }
       receiver_end_point = proxy_end_point;
     }
 
     std::string json_events;
     ASSERT_TRUE(tracing::BeginTracing("test_fps,mirroring,cast_perf_test"));
     const std::string page_url = base::StringPrintf(
         "performance%d.html?port=%d",
         getfps(),
         receiver_end_point.port());
     ASSERT_TRUE(RunExtensionSubtest("cast_streaming", page_url)) << message_;
     ASSERT_TRUE(tracing::EndTracing(&json_events));
     receiver->Stop();
 
     // Stop all threads, removes the need for synchronization when analyzing
     // the data.
     cast_environment->Shutdown();
     scoped_ptr<trace_analyzer::TraceAnalyzer> analyzer;
     analyzer.reset(trace_analyzer::TraceAnalyzer::Create(json_events));
     analyzer->AssociateAsyncBeginEndEvents();
 
     MeanAndError frame_data = AnalyzeTraceDistance(
         analyzer.get(),
-        TRACE_DISABLED_BY_DEFAULT("OnSwapCompositorFrame"));
+        "OnSwapCompositorFrame");
+
     EXPECT_GT(frame_data.num_values, 0UL);
     // Lower is better.
     frame_data.Print(test_name,
                      GetSuffixForTestFlags(),
                      "time_between_frames",
                      "ms");
 
     // This prints out the average time between capture events.
     // As the capture frame rate is capped at 30fps, this score
     // cannot get any better than (lower) 33.33 ms.
@@ skipping 21 matching lines @@
 // (it's a prefix for the generated test cases)
 INSTANTIATE_TEST_CASE_P(
     ,
     CastV2PerformanceTest,
     testing::Values(
         kUseGpu | k24fps,
         kUseGpu | k30fps,
         kUseGpu | k60fps,
         kUseGpu | k24fps | kDisableVsync,
         kUseGpu | k30fps | kProxyWifi,
-        kUseGpu | k30fps | kProxyEvil,
+        kUseGpu | k30fps | kProxyBad,
         kUseGpu | k30fps | kSlowClock,
         kUseGpu | k30fps | kFastClock));