[Chromecast] Consolidate duplicated crash test functions.

chromecast/crash/linux/minidump_writer_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 <fstream>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/test/scoped_path_override.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/minidump_generator.h"
 #include "chromecast/crash/linux/minidump_writer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace {
 
 const char kDumplogFile[] = "dumplog";
 const char kLockfileName[] = "lockfile";
 const char kMinidumpSubdir[] = "minidumps";
-const char kDumpsKey[] = "dumps";
 
 class FakeMinidumpGenerator : public MinidumpGenerator {
  public:
   FakeMinidumpGenerator() {}
   ~FakeMinidumpGenerator() override {}
 
   // MinidumpGenerator implementation:
   bool Generate(const std::string& minidump_path) override { return true; }
 };
 
 int FakeDumpState(const std::string& minidump_path) {
   return 0;
 }
 
-scoped_ptr<DumpInfo> CreateDumpInfo(const std::string& json_string) {
-  scoped_ptr<base::Value> value(DeserializeFromJson(json_string));
-  return make_scoped_ptr(new DumpInfo(value.get()));
-}
-
 }  // namespace
 
 class MinidumpWriterTest : public testing::Test {
  protected:
   MinidumpWriterTest() {}
   ~MinidumpWriterTest() override {}
 
   void SetUp() override {
     // Set up a temporary directory which will be used as our fake home dir.
     base::FilePath fake_home_dir;
     ASSERT_TRUE(base::CreateNewTempDirectory("", &fake_home_dir));
     home_.reset(new base::ScopedPathOverride(base::DIR_HOME, fake_home_dir));
     minidump_dir_ = fake_home_dir.Append(kMinidumpSubdir);
     dumplog_file_ = minidump_dir_.Append(kDumplogFile);
     lockfile_path_ = minidump_dir_.Append(kLockfileName);
 
     // Create the minidump directory and lockfile.
     ASSERT_TRUE(base::CreateDirectory(minidump_dir_));
     base::File lockfile(
         lockfile_path_,
         base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
     ASSERT_TRUE(lockfile.IsValid());
   }
 
-  int AppendLockFile(const DumpInfo& dump) {
-    scoped_ptr<base::Value> contents(DeserializeJsonFromFile(lockfile_path_));
-    if (!contents) {
-      base::DictionaryValue* dict = new base::DictionaryValue();
-      contents = make_scoped_ptr(dict);
-      dict->Set(kDumpsKey, make_scoped_ptr(new base::ListValue()));
-    }
-
-    base::DictionaryValue* dict;
-    base::ListValue* dump_list;
-    if (!contents || !contents->GetAsDictionary(&dict) ||
-        !dict->GetList(kDumpsKey, &dump_list) || !dump_list) {
-      return -1;
-    }
-
-    dump_list->Append(dump.GetAsValue());
-
-    return SerializeJsonToFile(lockfile_path_, *contents) ? 0 : -1;
+  bool AppendLockFile(const DumpInfo& dump) {
+    return chromecast::AppendLockFile(lockfile_path_.value(), dump);
   }
 
   FakeMinidumpGenerator fake_generator_;
   base::FilePath minidump_dir_;
   base::FilePath dumplog_file_;
   base::FilePath lockfile_path_;
 
  private:
   scoped_ptr<base::ScopedPathOverride> home_;
 
@@ skipping 55 matching lines @@
   for (size_t i = 0; i < too_many_dumps; ++i) {
     scoped_ptr<DumpInfo> info(CreateDumpInfo(
         "{"
         "\"name\": \"p\","
         "\"dump_time\" : \"2012-01-01 01:02:03\","
         "\"dump\": \"dump_string\","
         "\"uptime\": \"123456789\","
         "\"logfile\": \"logfile.log\""
         "}"));
     ASSERT_TRUE(info->valid());
-    ASSERT_EQ(0, AppendLockFile(*info));
+    ASSERT_TRUE(AppendLockFile(*info));
   }
 
   ASSERT_EQ(-1, writer.Write());
 }
 
 TEST_F(MinidumpWriterTest, Write_FailsWhenTooManyRecentDumpsPresent) {
   MinidumpWriter writer(&fake_generator_,
                         dumplog_file_.value(),
                         MinidumpParams(),
                         base::Bind(&FakeDumpState));
 
   // Write dump logs to the lockfile.
   size_t too_many_recent_dumps = writer.max_recent_dumps() + 1;
   for (size_t i = 0; i < too_many_recent_dumps; ++i) {
     MinidumpParams params;
     DumpInfo info("dump", "/dump/path", time(nullptr), params);
-    ASSERT_EQ(0, AppendLockFile(info));
+    ASSERT_TRUE(AppendLockFile(info));
   }
 
   ASSERT_EQ(-1, writer.Write());
 }
 
 TEST_F(MinidumpWriterTest, Write_SucceedsWhenDumpLimitsNotExceeded) {
   MinidumpWriter writer(&fake_generator_,
                         dumplog_file_.value(),
                         MinidumpParams(),
                         base::Bind(&FakeDumpState));
 
   ASSERT_GT(writer.max_dumps(), 1);
   ASSERT_GT(writer.max_recent_dumps(), 0);
 
   // Write an old dump logs to the lockfile.
   scoped_ptr<DumpInfo> info(CreateDumpInfo(
       "{"
       "\"name\": \"p\","
       "\"dump_time\" : \"2012-01-01 01:02:03\","
       "\"dump\": \"dump_string\","
       "\"uptime\": \"123456789\","
       "\"logfile\": \"logfile.log\""
       "}"));
   ASSERT_TRUE(info->valid());
-  ASSERT_EQ(0, AppendLockFile(*info));
+  ASSERT_TRUE(AppendLockFile(*info));
   ASSERT_EQ(0, writer.Write());
 }
 
 }  // namespace chromecast