Add new API function: feedbackPrivate.readLogSource

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

 // Copyright 2013 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 <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/metrics/user_metrics.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 47 matching lines @@
   "SrtPromptOnFeedbackForm", base::FEATURE_DISABLED_BY_DEFAULT
 };
 #endif
 
 }  // namespace
 
 namespace extensions {
 
 namespace feedback_private = api::feedback_private;
 
-using feedback_private::SystemInformation;
 using feedback_private::FeedbackInfo;
 using feedback_private::FeedbackFlow;
+using feedback_private::LogSource;
+using feedback_private::SystemInformation;
 
 using SystemInformationList =
     std::vector<api::feedback_private::SystemInformation>;
 
 static base::LazyInstance<BrowserContextKeyedAPIFactory<FeedbackPrivateAPI>>::
     DestructorAtExit g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<FeedbackPrivateAPI>*
 FeedbackPrivateAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 FeedbackPrivateAPI::FeedbackPrivateAPI(content::BrowserContext* context)
-    : browser_context_(context), service_(new FeedbackService()) {
-}
+    : browser_context_(context),
+      service_(new FeedbackService()),
+      log_source_access_manager_(new LogSourceAccessManager(context)) {}
 
-FeedbackPrivateAPI::~FeedbackPrivateAPI() {
-  delete service_;
-  service_ = NULL;
-}
+FeedbackPrivateAPI::~FeedbackPrivateAPI() {}
 
 FeedbackService* FeedbackPrivateAPI::GetService() const {
-  return service_;
+  return service_.get();
 }
 
 void FeedbackPrivateAPI::RequestFeedback(
     const std::string& description_template,
     const std::string& category_tag,
     const GURL& page_url) {
 #if defined(OS_WIN)
   // Show prompt for Software Removal Tool if the Reporter component has found
   // unwanted software, and the user has never run the cleaner before.
   if (base::FeatureList::IsEnabled(kSrtPromptOnFeedbackForm) &&
@@ skipping 146 matching lines @@
       sys_info_entry.key = std::move(itr.first);
       sys_info_entry.value = std::move(itr.second);
       sys_info_list.emplace_back(std::move(sys_info_entry));
     }
   }
 
   Respond(ArgumentList(
       feedback_private::GetSystemInformation::Results::Create(sys_info_list)));
 }
 
+ExtensionFunction::ResponseAction FeedbackPrivateReadLogSourceFunction::Run() {
+#if defined(OS_CHROMEOS)
+  using Params = feedback_private::ReadLogSource::Params;
+  std::unique_ptr<Params> api_params = Params::Create(*args_);
+
+  LogSourceAccessManager* log_source_manager =
+      FeedbackPrivateAPI::GetFactoryInstance()
+          ->Get(browser_context())
+          ->log_source_access_manager();
+
+  scoped_refptr<FeedbackPrivateReadLogSourceFunction> function = this;

[tbarzic, 2017/06/06 20:27:25]

you should not need this - just pass |this| to Bind(&OnCompleted)

[Simon Que, 2017/06/06 22:29:14]

Done.

+  if (!log_source_manager->FetchFromSource(
+          api_params->params, extension_id(),
+          base::Bind(&FeedbackPrivateReadLogSourceFunction::OnCompleted,
+                     function))) {
+    return RespondNow(Error("Unable to initiate fetch from log source."));
+  }
+
+  return RespondLater();
+#else
+  NOTREACHED() << "API function is not supported on this platform.";
+  return RespondNow(Error("API function is not supported on this platform."));
+#endif  // defined(OS_CHROMEOS)
+}
+
+#if defined(OS_CHROMEOS)
+void FeedbackPrivateReadLogSourceFunction::OnCompleted(
+    feedback_private::ReadLogSourceResult& result) {
+  Respond(
+      ArgumentList(feedback_private::ReadLogSource::Results::Create(result)));
+}
+#endif  // defined(OS_CHROMEOS)
+
 bool FeedbackPrivateSendFeedbackFunction::RunAsync() {
   std::unique_ptr<feedback_private::SendFeedback::Params> params(
       feedback_private::SendFeedback::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const FeedbackInfo &feedback_info = params->feedback;
 
   // Populate feedback data.
   scoped_refptr<FeedbackData> feedback_data(new FeedbackData());
   feedback_data->set_context(GetProfile());
@@ skipping 86 matching lines @@
     case feedback_private::SRT_PROMPT_RESULT_CLOSED:
       base::RecordAction(base::UserMetricsAction("Feedback.SrtPromptClosed"));
       break;
     default:
       return RespondNow(Error("Invalid arugment."));
   }
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions