Cleanup VersionInfo after componentization.

chrome/common/service_process_util.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/common/service_process_util.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/sha1.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/chrome_version_info.h"
 #include "components/cloud_devices/common/cloud_devices_switches.h"
+#include "components/version_info/version_info.h"
 #include "content/public/common/content_paths.h"
 #include "google_apis/gaia/gaia_switches.h"
 #include "ui/base/ui_base_switches.h"
 
 #if !defined(OS_MACOSX)
 
 namespace {
 
 // This should be more than enough to hold a version string assuming each part
 // of the version string is an int64.
@@ skipping 36 matching lines @@
   // At this time we have a version string. Set the out param if it exists.
   if (service_version_out)
     *service_version_out = version;
 
   Version service_version(version);
   // If the version string is invalid, treat it like an older version.
   if (!service_version.IsValid())
     return SERVICE_OLDER_VERSION_RUNNING;
 
   // Get the version of the currently *running* instance of Chrome.
-  chrome::VersionInfo version_info;
-  Version running_version(version_info.Version());
+  Version running_version(version_info::GetVersionNumber());
   if (!running_version.IsValid()) {
     NOTREACHED() << "Failed to parse version info";
     // Our own version is invalid. This is an error case. Pretend that we
     // are out of date.
     return SERVICE_NEWER_VERSION_RUNNING;
   }
 
   if (running_version.CompareTo(service_version) > 0) {
     return SERVICE_OLDER_VERSION_RUNNING;
   } else if (service_version.CompareTo(running_version) > 0) {
     return SERVICE_NEWER_VERSION_RUNNING;
   }
   return SERVICE_SAME_VERSION_RUNNING;
 }
 
 }  // namespace
 
 
 // Return a name that is scoped to this instance of the service process. We
 // use the user-data-dir and the version as a scoping prefix.
 std::string GetServiceProcessScopedVersionedName(
     const std::string& append_str) {
   std::string versioned_str;
-  chrome::VersionInfo version_info;
-  versioned_str.append(version_info.Version());
+  versioned_str.append(version_info::GetVersionNumber());
   versioned_str.append(append_str);
   return GetServiceProcessScopedName(versioned_str);
 }
 
 // Reads the named shared memory to get the shared data. Returns false if no
 // matching shared memory was found.
 bool GetServiceProcessData(std::string* version, base::ProcessId* pid) {
   scoped_ptr<base::SharedMemory> shared_mem_service_data;
   shared_mem_service_data.reset(new base::SharedMemory());
   ServiceProcessSharedData* service_data = NULL;
@@ skipping 111 matching lines @@
       // If an older version is running, kill it.
       ForceServiceProcessShutdown(running_version, process_id);
       break;
     case SERVICE_NOT_RUNNING:
       break;
   }
   return true;
 }
 
 bool ServiceProcessState::CreateSharedData() {
-  chrome::VersionInfo version_info;
-  if (version_info.Version().length() >= kMaxVersionStringLength) {
-    NOTREACHED() << "Version string length is << " <<
-        version_info.Version().length() << "which is longer than" <<
-        kMaxVersionStringLength;
+  if (version_info::GetVersionNumber().length() >= kMaxVersionStringLength) {
+    NOTREACHED() << "Version string length is << "
+                 << version_info::GetVersionNumber().length()
+                 << " which is longer than" << kMaxVersionStringLength;
     return false;
   }
 
   scoped_ptr<base::SharedMemory> shared_mem_service_data(
       new base::SharedMemory());
   if (!shared_mem_service_data.get())
     return false;
 
   uint32 alloc_size = sizeof(ServiceProcessSharedData);
   // TODO(viettrungluu): Named shared memory is deprecated (crbug.com/345734).
   if (!shared_mem_service_data->CreateNamedDeprecated
           (GetServiceProcessSharedMemName(), true, alloc_size))
     return false;
 
   if (!shared_mem_service_data->Map(alloc_size))
     return false;
 
   memset(shared_mem_service_data->memory(), 0, alloc_size);
   ServiceProcessSharedData* shared_data =
       reinterpret_cast<ServiceProcessSharedData*>(
           shared_mem_service_data->memory());
-  memcpy(shared_data->service_process_version, version_info.Version().c_str(),
-         version_info.Version().length());
+  memcpy(shared_data->service_process_version,
+         version_info::GetVersionNumber().c_str(),
+         version_info::GetVersionNumber().length());
   shared_data->service_process_pid = base::GetCurrentProcId();
   shared_mem_service_data_.reset(shared_mem_service_data.release());
   return true;
 }
 
 IPC::ChannelHandle ServiceProcessState::GetServiceProcessChannel() {
   return ::GetServiceProcessChannel();
 }
 
 #endif  // !OS_MACOSX