Rename SingleLogSource to SingleLogFileLogSource

chrome/browser/extensions/api/feedback_private/feedback_private_api_chromeos_unittest.cc

 // Copyright 2017 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 "chrome/browser/extensions/api/feedback_private/feedback_private_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/feedback_private/log_source_resource.h"
 #include "chrome/browser/extensions/api/feedback_private/single_log_source_factory.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
 #include "extensions/browser/api_test_utils.h"
 
 namespace extensions {
 
 namespace {
 
+using api::feedback_private::LogSource;
 using api::feedback_private::ReadLogSourceResult;
 using api::feedback_private::ReadLogSourceParams;
 using base::TimeDelta;
-using system_logs::SingleLogSource;
 using system_logs::SystemLogsResponse;
-using SupportedSource = system_logs::SingleLogSource::SupportedSource;
+using system_logs::SystemLogsSource;
 
 std::unique_ptr<KeyedService> ApiResourceManagerTestFactory(
     content::BrowserContext* context) {
   return base::MakeUnique<ApiResourceManager<LogSourceResource>>(context);
 }
 
 // Converts |params| to a string containing a JSON dictionary within an argument
 // list.
 std::string ParamsToJSON(const ReadLogSourceParams& params) {
   base::ListValue params_value;
   params_value.Append(params.ToValue());
   std::string params_json_string;
   EXPECT_TRUE(base::JSONWriter::Write(params_value, &params_json_string));
 
   return params_json_string;
 }
 
-// A dummy SingleLogSource that does not require real system logs to be
+// A dummy SystemLogsSource that does not require real system logs to be
 // available during testing.
-class TestSingleLogSource : public SingleLogSource {
+class TestSingleLogSource : public SystemLogsSource {
  public:
-  explicit TestSingleLogSource(SupportedSource type)
-      : SingleLogSource(type), call_count_(0) {}
+  explicit TestSingleLogSource(LogSource type)
+      : SystemLogsSource(ToString(type)), call_count_(0) {}
 
   ~TestSingleLogSource() override = default;
 
   // Fetch() will return a single different string each time, in the following
   // sequence: "a", " bb", "  ccc", until 25 spaces followed by 26 z's. Will
   // never return an empty result.
   void Fetch(const system_logs::SysLogsSourceCallback& callback) override {
     int count_modulus = call_count_ % kNumCharsToIterate;
     std::string result =
         std::string(count_modulus, ' ') +
         std::string(count_modulus + 1, kInitialChar + count_modulus);
     ASSERT_GT(result.size(), 0U);
     ++call_count_;
 
     SystemLogsResponse* result_map = new SystemLogsResponse;
     result_map->emplace("", result);
 
     // Do not directly pass the result to the callback, because that's not how
     // log sources actually work. Instead, simulate the asynchronous operation
-    // of a SingleLogSource by invoking the callback separately.
+    // of a SystemLogsSource by invoking the callback separately.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::BindOnce(callback, base::Owned(result_map)));
   }
 
   // Instantiates a new instance of this class. Does not retain ownership. Used
   // to create a Callback that can be used to override the default behavior of
   // SingleLogSourceFactory.
-  static std::unique_ptr<SingleLogSource> Create(SupportedSource type) {
+  static std::unique_ptr<SystemLogsSource> Create(LogSource type) {
     return base::MakeUnique<TestSingleLogSource>(type);
   }
 
  private:
   // Iterate over the whole lowercase alphabet, starting from 'a'.
   const int kNumCharsToIterate = 26;
   const char kInitialChar = 'a';
 
   // Keep track of how many times Fetch() has been called, in order to determine
   // its behavior each time.
@@ skipping 297 matching lines @@
   EXPECT_FALSE(
       RunReadLogSourceFunction(params, &result_reader_id, &result_string));
 
   // Another read is finally allowed at t=310.
   test_clock->Advance(TimeDelta::FromMilliseconds(1));
   EXPECT_TRUE(
       RunReadLogSourceFunction(params, &result_reader_id, &result_string));
 }
 
 }  // namespace extensions