Move statistics_provider to chromeos/system

chrome/browser/policy/cloud/device_management_service.cc

 // Copyright (c) 2012 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/policy/cloud/device_management_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/strings/stringprintf.h"
+#include "base/sys_info.h"
+#include "chromeos/system/statistics_provider.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_response_headers.h"
 #include "net/proxy/proxy_service.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
+#if defined(OS_CHROMEOS)
+#include "chromeos/system/statistics_provider.h"

[Joao da Silva, 2013/10/02 10:06:26]

Unfortunately this is a no-go. We are moving this code into a component (to
enable it on iOS) and can't depend on //chrome nor //chromeos code.

I've fixed the GetMachineStatistic() issue at
https://codereview.chromium.org/25690003 by introducing a delegate here; it
shouldn't be necessary to change this file (nor the DEPS) anymore. Updating the
#include path in browser_policy_connector.cc should suffice.

[stevenjb, 2013/10/02 16:59:49]

Components *can* rely on /src/chromeos. I'll look at your fix, that should be
fine also, but we do already have components with chromeos dependencies.

[stevenjb, 2013/10/03 01:17:23]

https://codereview.chromium.org/25690003 is definitely a better fix, cheers.

+#endif
+
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 const char kPostContentType[] = "application/protobuf";
 
 const char kServiceTokenAuthHeader[] = "Authorization: GoogleLogin auth=";
 const char kDMTokenAuthHeader[] = "Authorization: GoogleDMToken token=";
@@ skipping 168 matching lines @@
   }
 
   return context_.get();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 DeviceManagementRequestContextGetter::GetNetworkTaskRunner() const {
   return base_context_getter_->GetNetworkTaskRunner();
 }
 
+std::string GetPlatformParameter() {
+  std::string os_name = base::SysInfo::OperatingSystemName();
+  std::string os_hardware = base::SysInfo::OperatingSystemArchitecture();
+
+#if defined(OS_CHROMEOS)
+  std::string hwclass;
+  if (!chromeos::system::StatisticsProvider::GetInstance()
+      ->GetMachineStatistic(chromeos::system::kHardwareClassKey, &hwclass)) {
+    LOG(ERROR) << "Failed to get machine information";
+  }
+  os_name += ",CrOS," + base::SysInfo::GetLsbReleaseBoard();
+  os_hardware += "," + hwclass;
+#endif
+
+  std::string os_version("-");
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_CHROMEOS)
+  int32 os_major_version = 0;
+  int32 os_minor_version = 0;
+  int32 os_bugfix_version = 0;
+  base::SysInfo::OperatingSystemVersionNumbers(&os_major_version,
+                                               &os_minor_version,
+                                               &os_bugfix_version);
+  os_version = base::StringPrintf("%d.%d.%d",
+                                  os_major_version,
+                                  os_minor_version,
+                                  os_bugfix_version);
+#endif
+
+  return base::StringPrintf(
+      "%s|%s|%s", os_name.c_str(), os_hardware.c_str(), os_version.c_str());
+}
+
 }  // namespace
 
 // Request job implementation used with DeviceManagementService.
 class DeviceManagementRequestJobImpl : public DeviceManagementRequestJob {
  public:
   DeviceManagementRequestJobImpl(JobType type,
                                  const std::string& agent_parameter,
                                  const std::string& platform_parameter,
                                  DeviceManagementService* service);
   virtual ~DeviceManagementRequestJobImpl();
@@ skipping 250 matching lines @@
 const int DeviceManagementService::kURLFetcherID = 0xde71ce1d;
 
 DeviceManagementService::~DeviceManagementService() {
   // All running jobs should have been cancelled by now.
   DCHECK(pending_jobs_.empty());
   DCHECK(queued_jobs_.empty());
 }
 
 DeviceManagementRequestJob* DeviceManagementService::CreateJob(
     DeviceManagementRequestJob::JobType type) {
+  if (platform_parameter_.empty())
+    platform_parameter_ = GetPlatformParameter();
   return new DeviceManagementRequestJobImpl(
       type, agent_parameter_, platform_parameter_, this);
 }
 
 void DeviceManagementService::ScheduleInitialization(int64 delay_milliseconds) {
   if (initialized_)
     return;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&DeviceManagementService::Initialize,
@@ skipping 22 matching lines @@
     delete job->first;
     queued_jobs_.push_back(job->second);
   }
   pending_jobs_.clear();
 }
 
 DeviceManagementService::DeviceManagementService(
     scoped_refptr<net::URLRequestContextGetter> request_context,
     const std::string& server_url,
     const std::string& user_agent,
-    const std::string& agent_parameter,
-    const std::string& platform_parameter)
+    const std::string& agent_parameter)
     : request_context_(request_context),
       server_url_(server_url),
       user_agent_(user_agent),
       agent_parameter_(agent_parameter),
-      platform_parameter_(platform_parameter),
       initialized_(false),
       weak_ptr_factory_(this) {
 }
 
 void DeviceManagementService::StartJob(DeviceManagementRequestJobImpl* job) {
   net::URLFetcher* fetcher = net::URLFetcher::Create(
       kURLFetcherID, job->GetURL(server_url_), net::URLFetcher::POST, this);
   fetcher->SetRequestContext(request_context_getter_.get());
   job->ConfigureRequest(fetcher);
   pending_jobs_[fetcher] = job;
@@ skipping 42 matching lines @@
     }
   }
 
   const JobQueue::iterator elem =
       std::find(queued_jobs_.begin(), queued_jobs_.end(), job);
   if (elem != queued_jobs_.end())
     queued_jobs_.erase(elem);
 }
 
 }  // namespace policy