[Chromecast] Consolidate duplicated crash test functions.

chromecast/crash/linux/synchronized_minidump_manager_unittest.cc

 // Copyright 2015 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 <fcntl.h>
 #include <stdlib.h>
 #include <sys/file.h>
 #include <sys/stat.h>   // mkdir
 #include <sys/types.h>  //
 #include <stdio.h>      // perror
 #include <time.h>
 
 #include <fstream>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/process/launch.h"
 #include "base/test/scoped_path_override.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
-#include "chromecast/base/serializers.h"
+#include "chromecast/crash/linux/crash_testing_utils.h"
 #include "chromecast/crash/linux/dump_info.h"
 #include "chromecast/crash/linux/synchronized_minidump_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace {
 
 const char kLockfileName[] = "lockfile";
 const char kMinidumpSubdir[] = "minidumps";
-const char kDumpsKey[] = "dumps";
 
 // A trivial implementation of SynchronizedMinidumpManager, which does no work
 // to the
 // minidump and exposes its protected members for testing.
 class SynchronizedMinidumpManagerSimple : public SynchronizedMinidumpManager {
  public:
   SynchronizedMinidumpManagerSimple()
       : SynchronizedMinidumpManager(),
         work_done_(false),
         add_entry_return_code_(-1),
@@ skipping 20 matching lines @@
   bool work_done() { return work_done_; }
   int add_entry_return_code() { return add_entry_return_code_; }
 
  private:
   bool work_done_;
   int add_entry_return_code_;
   std::string lockfile_path_;
   scoped_ptr<DumpInfo> dump_info_;
 };
 
-bool FetchDumps(const std::string& lockfile_path,
-                ScopedVector<DumpInfo>* dumps) {
-  if (!dumps) {
-    return false;
-  }
-  dumps->clear();
-
-  base::FilePath path(lockfile_path);
-  scoped_ptr<base::Value> contents(DeserializeJsonFromFile(path));
-
-  base::DictionaryValue* dict;
-  base::ListValue* dump_list;
-  if (!contents || !contents->GetAsDictionary(&dict) ||
-      !dict->GetList(kDumpsKey, &dump_list) || !dump_list) {
-    return false;
-  }
-
-  for (base::Value* elem : *dump_list) {
-    scoped_ptr<DumpInfo> dump = make_scoped_ptr(new DumpInfo(elem));
-    if (!dump->valid()) {
-      return false;
-    }
-    dumps->push_back(dump.Pass());
-  }
-
-  return true;
-}
-
-bool CreateLockFile(const std::string& lockfile_path) {
-  scoped_ptr<base::DictionaryValue> output =
-      make_scoped_ptr(new base::DictionaryValue());
-  output->Set("dumps", make_scoped_ptr(new base::ListValue()));
-
-  base::FilePath path(lockfile_path);
-
-  const base::Value* val = output.get();
-  return SerializeJsonToFile(path, *val);
-}
-
 void DoWorkLockedTask(SynchronizedMinidumpManagerSimple* manager) {
   manager->DoWorkLocked();
 }
 
 class SleepySynchronizedMinidumpManagerSimple
     : public SynchronizedMinidumpManagerSimple {
  public:
   SleepySynchronizedMinidumpManagerSimple(int sleep_duration_ms)
       : SynchronizedMinidumpManagerSimple(),
         sleep_duration_ms_(sleep_duration_ms) {}
@@ skipping 289 matching lines @@
   EXPECT_EQ(0, manager.add_entry_return_code());
   EXPECT_TRUE(manager.work_done());
 
   // Test that both entries were logged.
   ScopedVector<DumpInfo> dumps;
   ASSERT_TRUE(FetchDumps(lockfile_.value(), &dumps));
   EXPECT_EQ(2u, dumps.size());
 }
 
 }  // namespace chromecast