Split SystemAccess into TimezoneSettings, StatisticsProvider, and SyslogsProvider.

chrome/browser/ui/webui/net_internals_ui.cc

 // Copyright (c) 2011 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/ui/webui/net_internals_ui.h"
 
 #include <algorithm>
 #include <list>
 #include <string>
 #include <utility>
@@ skipping 44 matching lines @@
 #include "net/http/http_network_session.h"
 #include "net/http/http_stream_factory.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #ifdef OS_CHROMEOS
 #include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/system_access.h"
+#include "chrome/browser/chromeos/system/syslogs_provider.h"
 #endif
 #ifdef OS_WIN
 #include "chrome/browser/net/service_providers_win.h"
 #endif
 
 namespace {
 
 // Delay between when an event occurs and when it is passed to the Javascript
 // page.  All events that occur during this period are grouped together and
 // sent to the page at once, which reduces context switching and CPU usage.
@@ skipping 110 matching lines @@
   // Class that is used for getting network related ChromeOS logs.
   // Logs are fetched from ChromeOS libcros on user request, and only when we
   // don't yet have a copy of logs. If a copy is present, we send back data from
   // it, else we save request and answer to it when we get logs from libcros.
   // If needed, we also send request for system logs to libcros.
   // Logs refresh has to be done explicitly, by deleting old logs and then
   // loading them again.
   class SystemLogsGetter {
    public:
     SystemLogsGetter(NetInternalsMessageHandler* handler,
-                     chromeos::SystemAccess* system_access);
+                     chromeos::system::SyslogsProvider* syslogs_provider);
     ~SystemLogsGetter();
 
     // Deletes logs copy we currently have, and resets logs_requested and
     // logs_received flags.
     void DeleteSystemLogs();
     // Starts log fetching. If logs copy is present, requested logs are sent
     // back.
     // If syslogs load request hasn't been sent to libcros yet, we do that now,
     // and postpone sending response.
     // Request data is specified by args:
     //   $1 : key of the log we are interested in.
     //   $2 : string used to identify request.
     void RequestSystemLog(const ListValue* args);
     // Requests logs from libcros, but only if we don't have a copy.
     void LoadSystemLogs();
     // Processes callback from libcros containing system logs. Postponed
     // request responses are sent.
-    void OnSystemLogsLoaded(chromeos::LogDictionaryType* sys_info,
+    void OnSystemLogsLoaded(chromeos::system::LogDictionaryType* sys_info,
                             std::string* ignored_content);
 
    private:
     // Struct we save postponed log request in.
     struct SystemLogRequest {
       std::string log_key;
       std::string cell_id;
     };
 
     // Processes request.
     void SendLogs(const SystemLogRequest& request);
 
     NetInternalsMessageHandler* handler_;
-    chromeos::SystemAccess* system_access_;
+    chromeos::system::SyslogsProvider* syslogs_provider_;
     // List of postponed requests.
     std::list<SystemLogRequest> requests_;
-    scoped_ptr<chromeos::LogDictionaryType> logs_;
+    scoped_ptr<chromeos::system::LogDictionaryType> logs_;
     bool logs_received_;
     bool logs_requested_;
     CancelableRequestConsumer consumer_;
     // Libcros request handle.
     CancelableRequestProvider::Handle syslogs_request_id_;
   };
 #endif
 
   // The pref member about whether HTTP throttling is enabled, which needs to
   // be accessed on the UI thread.
@@ skipping 276 matching lines @@
   PrefService* pref_service = web_ui->GetProfile()->GetPrefs();
   http_throttling_enabled_.Init(
       prefs::kHttpThrottlingEnabled, pref_service, this);
   http_throttling_may_experiment_.Init(
       prefs::kHttpThrottlingMayExperiment, pref_service, NULL);
 
   proxy_ = new IOThreadImpl(this->AsWeakPtr(), g_browser_process->io_thread(),
                             web_ui->GetProfile()->GetRequestContext());
 #ifdef OS_CHROMEOS
   syslogs_getter_.reset(new SystemLogsGetter(this,
-      chromeos::SystemAccess::GetInstance()));
+      chromeos::system::SyslogsProvider::GetInstance()));
 #endif
   renderer_ready_io_callback_.reset(
       proxy_->CreateCallback(&IOThreadImpl::OnRendererReady));
 
   prerender::PrerenderManager* prerender_manager =
       web_ui->GetProfile()->GetPrerenderManager();
   if (prerender_manager) {
     prerender_manager_ = prerender_manager->AsWeakPtr();
   } else {
     prerender_manager_ = base::WeakPtr<prerender::PrerenderManager>();
@@ skipping 164 matching lines @@
 
 #ifdef OS_CHROMEOS
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NetInternalsMessageHandler::SystemLogsGetter
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 NetInternalsMessageHandler::SystemLogsGetter::SystemLogsGetter(
     NetInternalsMessageHandler* handler,
-    chromeos::SystemAccess* system_access)
+    chromeos::system::SyslogsProvider* syslogs_provider)
     : handler_(handler),
-      system_access_(system_access),
+      syslogs_provider_(syslogs_provider),
       logs_(NULL),
       logs_received_(false),
       logs_requested_(false) {
-  if (!system_access_)
+  if (!syslogs_provider_)
     LOG(ERROR) << "System access library not loaded";
 }
 
 NetInternalsMessageHandler::SystemLogsGetter::~SystemLogsGetter() {
   DeleteSystemLogs();
 }
 
 void NetInternalsMessageHandler::SystemLogsGetter::DeleteSystemLogs() {
-  if (system_access_ && logs_requested_ && !logs_received_) {
-    system_access_->CancelRequest(syslogs_request_id_);
+  if (syslogs_provider_ && logs_requested_ && !logs_received_) {
+    syslogs_provider_->CancelRequest(syslogs_request_id_);
   }
   logs_requested_ = false;
   logs_received_ = false;
   logs_.reset();
 }
 
 void NetInternalsMessageHandler::SystemLogsGetter::RequestSystemLog(
     const ListValue* args) {
   if (!logs_requested_) {
     DCHECK(!logs_received_);
     LoadSystemLogs();
   }
   SystemLogRequest log_request;
   args->GetString(0, &log_request.log_key);
   args->GetString(1, &log_request.cell_id);
 
   if (logs_received_) {
     SendLogs(log_request);
   } else {
     requests_.push_back(log_request);
   }
 }
 
 void NetInternalsMessageHandler::SystemLogsGetter::LoadSystemLogs() {
-  if (logs_requested_ || !system_access_)
+  if (logs_requested_ || !syslogs_provider_)
     return;
   logs_requested_ = true;
-  syslogs_request_id_ = system_access_->RequestSyslogs(
+  syslogs_request_id_ = syslogs_provider_->RequestSyslogs(
       false,  // compress logs.
-      chromeos::SystemAccess::SYSLOGS_NETWORK,
+      chromeos::system::SyslogsProvider::SYSLOGS_NETWORK,
       &consumer_,
       NewCallback(
           this,
           &NetInternalsMessageHandler::SystemLogsGetter::OnSystemLogsLoaded));
 }
 
 void NetInternalsMessageHandler::SystemLogsGetter::OnSystemLogsLoaded(
-    chromeos::LogDictionaryType* sys_info, std::string* ignored_content) {
+    chromeos::system::LogDictionaryType* sys_info,
+    std::string* ignored_content) {
   DCHECK(!ignored_content);
   logs_.reset(sys_info);
   logs_received_ = true;
   for (std::list<SystemLogRequest>::iterator request_it = requests_.begin();
        request_it != requests_.end();
        ++request_it) {
     SendLogs(*request_it);
   }
   requests_.clear();
 }
 
 void NetInternalsMessageHandler::SystemLogsGetter::SendLogs(
     const SystemLogRequest& request) {
   DictionaryValue* result = new DictionaryValue();
-  chromeos::LogDictionaryType::iterator log_it = logs_->find(request.log_key);
+  chromeos::system::LogDictionaryType::iterator log_it =
+      logs_->find(request.log_key);
   if (log_it != logs_->end()) {
     if (!log_it->second.empty()) {
       result->SetString("log", log_it->second);
     } else {
       result->SetString("log", "<no relevant lines found>");
     }
   } else {
     result->SetString("log", "<invalid log name>");
   }
   result->SetString("cellId", request.cell_id);
@@ skipping 801 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 NetInternalsUI::NetInternalsUI(TabContents* contents) : ChromeWebUI(contents) {
   AddMessageHandler((new NetInternalsMessageHandler())->Attach(this));
 
   NetInternalsHTMLSource* html_source = new NetInternalsHTMLSource();
 
   // Set up the chrome://net-internals/ source.
   GetProfile()->GetChromeURLDataManager()->AddDataSource(html_source);
 }