Rename SingleLogSource to SingleLogFileLogSource

chrome/browser/extensions/api/feedback_private/log_source_access_manager.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/log_source_access_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/time/default_tick_clock.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 "extensions/browser/api/api_resource_manager.h"
 
 namespace extensions {
 
 namespace {
 
 namespace feedback_private = api::feedback_private;
-using feedback_private::LogSource;
-using SingleLogSource = system_logs::SingleLogSource;
-using SupportedSource = system_logs::SingleLogSource::SupportedSource;
+
 using SystemLogsResponse = system_logs::SystemLogsResponse;
 
 const int kMaxReadersPerSource = 10;
 
 // The minimum time between consecutive reads of a log source by a particular
 // extension.
 const int kDefaultRateLimitingTimeoutMs = 1000;
 
 // If this is null, then |kDefaultRateLimitingTimeoutMs| is used as the timeout.
 const base::TimeDelta* g_rate_limiting_timeout = nullptr;
 
 base::TimeDelta GetMinTimeBetweenReads() {
   return g_rate_limiting_timeout
              ? *g_rate_limiting_timeout
              : base::TimeDelta::FromMilliseconds(kDefaultRateLimitingTimeoutMs);
 }
 
-// Converts from feedback_private::LogSource to SupportedSource.
-SupportedSource GetSupportedSourceType(LogSource source) {
-  switch (source) {
-    case feedback_private::LOG_SOURCE_MESSAGES:
-      return SupportedSource::kMessages;
-    case feedback_private::LOG_SOURCE_UILATEST:
-      return SupportedSource::kUiLatest;
-    case feedback_private::LOG_SOURCE_NONE:
-    default:
-      NOTREACHED() << "Unknown log source type.";
-      return SingleLogSource::SupportedSource::kMessages;
-  }
-  NOTREACHED();
-  return SingleLogSource::SupportedSource::kMessages;
-}
-
 // SystemLogsResponse is a map of strings -> strings. The map value has the
 // actual log contents, a string containing all lines, separated by newlines.
 // This function extracts the individual lines and converts them into a vector
 // of strings, each string containing a single line.
 void GetLogLinesFromSystemLogsResponse(const SystemLogsResponse& response,
                                        std::vector<std::string>* log_lines) {
   for (const std::pair<std::string, std::string>& pair : response) {
     std::vector<std::string> new_lines = base::SplitString(
         pair.second, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
     log_lines->reserve(log_lines->size() + new_lines.size());
@@ skipping 79 matching lines @@
   }
 
   callback.Run(result);
 }
 
 void LogSourceAccessManager::RemoveSource(const SourceAndExtension& key) {
   sources_.erase(key);
 }
 
 LogSourceAccessManager::SourceAndExtension::SourceAndExtension(
-    api::feedback_private::LogSource source,
+    feedback_private::LogSource source,
     const std::string& extension_id)
     : source(source), extension_id(extension_id) {}
 
 int LogSourceAccessManager::CreateResource(const SourceAndExtension& key) {
   // Enforce the rules: Do not create a new SingleLogSource if there was already
   // one created for |key|.
   if (sources_.find(key) != sources_.end())
     return 0;
 
   // Enforce the rules: Do not create too many SingleLogSource objects to read
   // from a source, even if they are from different extensions.
   if (GetNumActiveResourcesForSource(key.source) >= kMaxReadersPerSource)
     return 0;
 
   std::unique_ptr<LogSourceResource> new_resource =
       base::MakeUnique<LogSourceResource>(
           key.extension_id,
-          SingleLogSourceFactory::CreateSingleLogSource(
-              GetSupportedSourceType(key.source)),
+          SingleLogSourceFactory::CreateSingleLogSource(key.source),
           base::Bind(&LogSourceAccessManager::RemoveSource,
                      weak_factory_.GetWeakPtr(), key));
 
   int id = ApiResourceManager<LogSourceResource>::Get(context_)->Add(
       new_resource.release());
   sources_[key] = id;
 
   return id;
 }
 
@@ skipping 11 matching lines @@
 base::TimeTicks LogSourceAccessManager::GetLastExtensionAccessTime(
     const SourceAndExtension& key) const {
   const auto iter = last_access_times_.find(key);
   if (iter == last_access_times_.end())
     return base::TimeTicks();
 
   return iter->second;
 }
 
 size_t LogSourceAccessManager::GetNumActiveResourcesForSource(
-    api::feedback_private::LogSource source) const {
+    feedback_private::LogSource source) const {
   size_t count = 0;
   // The stored entries are sorted first by source type, then by extension ID.
   // We can take advantage of this fact to avoid iterating over all elements.
   // Instead start from the first element that matches |source|, and end at the
   // first element that does not match |source| anymore.
   for (auto iter = sources_.lower_bound(SourceAndExtension(source, ""));
        iter != sources_.end() && iter->first.source == source; ++iter) {
     ++count;
   }
   return count;
 }
 
 }  // namespace extensions