Reenable the WebRTC EventLog API Tests.

chrome/browser/extensions/api/webrtc_logging_private/webrtc_event_log_apitest.cc

 // Copyright 2016 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 <memory>
 #include <utility>
 
 #include "base/command_line.h"
+#include "base/files/file_path_watcher.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ref_counted.h"
+#include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/webrtc_logging_private/webrtc_logging_private_api.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/media/webrtc_browsertest_base.h"
 #include "chrome/browser/media/webrtc_browsertest_common.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 11 matching lines @@
 #endif
 
 using extensions::WebrtcLoggingPrivateStartWebRtcEventLoggingFunction;
 using extensions::WebrtcLoggingPrivateStopWebRtcEventLoggingFunction;
 
 namespace utils = extension_function_test_utils;
 
 namespace {
 
 // Get the expected EventLog file name. The name will be
-// <temporary path>.<render process id>.event_log.<consumer id>, for example
+// <temporary path>.<render process id>.<peer connection id>, for example
 // /tmp/.org.chromium.Chromium.vsygNQ/dnFW8ch/Default/WebRTC
-// Logs/WebRtcEventLog.1.29113.event_log.1
+// Logs/WebRtcEventLog.1.6.1
 base::FilePath GetExpectedEventLogFileName(const base::FilePath& base_file,
                                            int render_process_id) {
-  static const int kExpectedConsumerId = 1;
+  static const int kExpectedPeerConnectionId = 1;
   return base_file.AddExtension(IntToStringType(render_process_id))
-      .AddExtension(FILE_PATH_LITERAL("event_log"))
-      .AddExtension(IntToStringType(kExpectedConsumerId));
+      .AddExtension(IntToStringType(kExpectedPeerConnectionId));
 }
 
 static const char kMainWebrtcTestHtmlPage[] = "/webrtc/webrtc_jsep01_test.html";
 
 std::string ParamsToString(const base::ListValue& parameters) {
   std::string parameter_string;
   EXPECT_TRUE(base::JSONWriter::Write(parameters, &parameter_string));
   return parameter_string;
 }
 
+class FileWatcher : public base::RefCountedThreadSafe<FileWatcher> {

[asargent_no_longer_on_chrome, 2016/07/21 23:19:27]

nit: using the same name as the class in base can be confusing for things like
find/grep, codesearch, etc. even though namespaces let it compile. I'd prefer if
you used some distinct name for this class, perhaps something like
"BlockingFileWatcher" or "FileWaiter" (feel free to use something else if you
have a better idea) 

[Ivo-OOO until feb 6, 2016/07/22 09:21:04]

Good point, I renamed it to FileWaiter.

+ public:
+  explicit FileWatcher(const base::FilePath& path)
+      : found_(false), path_(path) {}
+
+  bool Start() {
+    if (base::PathExists(path_)) {
+      found_ = true;
+      return true;
+    } else {
+      return watcher_.Watch(path_, false /* recursive */,
+                            base::Bind(&FileWatcher::Callback, this));
+    }
+  }
+
+  // Returns true if |path_| became available.
+  bool WaitForFile() {
+    if (!found_) {
+      run_loop_.Run();
+    }
+    return found_;
+  }
+
+  // implements FilePathWatcher::Callback
+  void Callback(const base::FilePath& path, bool error) {
+    EXPECT_EQ(path, path_);
+    if (!error)
+      found_ = true;
+    run_loop_.Quit();
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<FileWatcher>;
+  ~FileWatcher() {}
+  base::RunLoop run_loop_;
+  bool found_;
+  base::FilePath path_;
+  base::FilePathWatcher watcher_;
+  DISALLOW_COPY_AND_ASSIGN(FileWatcher);
+};
+
 class WebrtcEventLogApiTest : public WebRtcTestBase {
  protected:
   void SetUp() override {
     WebRtcTestBase::SetUp();
     extension_ = extensions::test_util::CreateEmptyExtension();
   }
 
   void SetUpInProcessBrowserTestFixture() override {
     DetectErrorsInJavaScript();  // Look for errors in our rather complex js.
   }
@@ skipping 30 matching lines @@
     parameters->Append(std::move(request_info));
     parameters->AppendString(tab->GetURL().GetOrigin().spec());
   }
 
  private:
   scoped_refptr<extensions::Extension> extension_;
 };
 
 }  // namespace
 
-// TODO(ivoc): Reenable when the event log functionality in Chrome is updated.
-IN_PROC_BROWSER_TEST_F(WebrtcEventLogApiTest,
-                       DISABLED_TestStartStopWebRtcEventLogging) {
+IN_PROC_BROWSER_TEST_F(WebrtcEventLogApiTest, TestStartStopWebRtcEventLogging) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   content::WebContents* left_tab =
       OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
   content::WebContents* right_tab =
       OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
 
   SetupPeerconnectionWithLocalStream(left_tab);
   SetupPeerconnectionWithLocalStream(right_tab);
 
@@ skipping 48 matching lines @@
   ASSERT_TRUE(recordings_info_stop.get());
   base::FilePath file_name_stop(
       base::FilePath::FromUTF8Unsafe(recordings_info_stop->prefix_path));
 
   HangUp(left_tab);
   HangUp(right_tab);
 
   EXPECT_EQ(file_name_start, file_name_stop);
 
   // Check that the file exists and is non-empty.
-  base::ProcessId render_process_id =
-      base::GetProcId(left_tab->GetRenderProcessHost()->GetHandle());
-  EXPECT_NE(render_process_id, base::kNullProcessId);
+  content::RenderProcessHost* render_process_host =
+      left_tab->GetRenderProcessHost();
+  ASSERT_NE(render_process_host, nullptr);
+  int render_process_id = render_process_host->GetID();
   base::FilePath full_file_name =
       GetExpectedEventLogFileName(file_name_stop, render_process_id);
   int64_t file_size = 0;
-  while (!(base::PathExists(full_file_name) &&
-           base::GetFileSize(full_file_name, &file_size) && file_size > 0)) {
-    // This should normally not happen, but is here to prevent the test
-    // from becoming flaky on devices with weird timings or when the
-    // /webrtc/webrtc_jsep01_test.html changes.
-    VLOG(1) << "Waiting for logfile to become available...";
-    base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
-  }
+  scoped_refptr<FileWatcher> watcher = new FileWatcher(full_file_name);
+
+  ASSERT_TRUE(watcher->Start()) << "ERROR watching for "
+                                << full_file_name.value();
+  ASSERT_TRUE(watcher->WaitForFile());
   ASSERT_TRUE(base::PathExists(full_file_name));
   EXPECT_TRUE(base::GetFileSize(full_file_name, &file_size));
   EXPECT_GT(file_size, 0);
 
   // Clean up.
   base::DeleteFile(full_file_name, false);
 }
 
-// TODO(ivoc): Reenable when the event log functionality in Chrome is updated.
 IN_PROC_BROWSER_TEST_F(WebrtcEventLogApiTest,
-                       DISABLED_TestStartTimedWebRtcEventLogging) {
+                       TestStartTimedWebRtcEventLogging) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   content::WebContents* left_tab =
       OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
   content::WebContents* right_tab =
       OpenTestPageAndGetUserMediaInNewTab(kMainWebrtcTestHtmlPage);
 
   SetupPeerconnectionWithLocalStream(left_tab);
   SetupPeerconnectionWithLocalStream(right_tab);
 
@@ skipping 29 matching lines @@
   // Video is choppy on Mac OS X. http://crbug.com/443542.
   WaitForVideoToPlay(left_tab);
   WaitForVideoToPlay(right_tab);
 #endif
 
   HangUp(left_tab);
   HangUp(right_tab);
 
   // The log has stopped automatically. Check that the file exists and is
   // non-empty.
-  base::ProcessId render_process_id =
-      base::GetProcId(left_tab->GetRenderProcessHost()->GetHandle());
-  EXPECT_NE(render_process_id, base::kNullProcessId);
+  content::RenderProcessHost* render_process_host =
+      left_tab->GetRenderProcessHost();
+  ASSERT_NE(render_process_host, nullptr);
+  int render_process_id = render_process_host->GetID();
   base::FilePath full_file_name =
       GetExpectedEventLogFileName(file_name_start, render_process_id);
   int64_t file_size = 0;
-  while (!(base::PathExists(full_file_name) &&
-           base::GetFileSize(full_file_name, &file_size) && file_size > 0)) {
-    // This should normally not happen, but is here to prevent the test
-    // from becoming flaky on devices with weird timings or when the
-    // /webrtc/webrtc_jsep01_test.html changes.
-    VLOG(1) << "Waiting for logfile to become available...";
-    base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
-  }
+
+  scoped_refptr<FileWatcher> watcher = new FileWatcher(full_file_name);
+
+  ASSERT_TRUE(watcher->Start()) << "ERROR watching for "
+                                << full_file_name.value();
+  ASSERT_TRUE(watcher->WaitForFile());
   ASSERT_TRUE(base::PathExists(full_file_name));
   EXPECT_TRUE(base::GetFileSize(full_file_name, &file_size));
   EXPECT_GT(file_size, 0);
 
   // Clean up.
   base::DeleteFile(full_file_name, false);
 }