Use InstallDetails in installer_util.

chrome/installer/util/channel_info.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/installer/util/channel_info.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"

[gab, 2017/02/14 16:57:56]

rm these two and add string16.h

[grt (UTC plus 2), 2017/02/14 21:04:23]

Removed! string16.h is included in channel_info.h, so leaving that out.

 #include "base/win/registry.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/util_constants.h"
 
 using base::win::RegKey;
 
 namespace {
 
 const wchar_t kModChrome[] = L"-chrome";
 const wchar_t kModChromeFrame[] = L"-chromeframe";
@@ skipping 108 matching lines @@
     }
   } else {
     if (have_modifier) {
       ap_value->erase(position, length);
       return true;
     }
   }
   return false;
 }
 
-// Returns the position of the first case-insensitive match of |pattern| found
-// in |str|, or base::string16::npos if none found. |pattern| must be non-empty
-// lower-case ASCII, and may contain any number of '.' wildcard characters.
-size_t FindSubstringMatch(const base::string16& str,
-                          base::StringPiece16 pattern) {
-  DCHECK(!pattern.empty());
-  DCHECK(base::IsStringASCII(pattern));
-  DCHECK(pattern == base::StringPiece16(base::ToLowerASCII(pattern)));
-
-  if (str.size() < pattern.size())
-    return base::string16::npos;
-
-  for (size_t i = 0; i < str.size() - pattern.size() + 1; ++i) {
-    size_t j = 0;
-    while (j < pattern.size() &&
-           (pattern[j] == L'.' ||
-            pattern[j] == base::ToLowerASCII(str[i+j]))) {
-      ++j;
-    }
-    if (j == pattern.size())
-      return i;
-  }
-  return base::string16::npos;
-}
-
 // Returns the value of a modifier - that is for a modifier of the form
 // "-foo:bar", returns "bar". Returns an empty string if the modifier
 // is not present or does not have a value.
 base::string16 GetModifierValue(ModifierIndex modifier_index,
                                 const base::string16& value) {
   base::string16::size_type position;
   base::string16::size_type length;
 
   if (FindModifier(modifier_index, value, &position, &length)) {
     // Return the portion after the prefix.
@@ skipping 21 matching lines @@
   LONG result = value_.empty() ?
       key->DeleteValue(google_update::kRegApField) :
       key->WriteValue(google_update::kRegApField, value_.c_str());
   if (result != ERROR_SUCCESS) {
     LOG(ERROR) << "Failed writing channel info; result: " << result;
     return false;
   }
   return true;
 }
 
-bool ChannelInfo::GetChannelName(base::string16* channel_name) const {
-  static const wchar_t kChromeChannelBetaPattern[] = L"1.1-";
-  static const wchar_t kChromeChannelBetaX64Pattern[] = L"x64-beta";
-  static const wchar_t kChromeChannelDevPattern[] = L"2.0-d";
-  static const wchar_t kChromeChannelDevX64Pattern[] = L"x64-dev";
-
-  DCHECK(channel_name);
-  // Report channels that are empty string or contain "stable" as stable
-  // (empty string).
-  if (value_.empty() || value_.find(installer::kChromeChannelStableExplicit) !=
-      base::string16::npos) {
-    channel_name->erase();
-    return true;
-  }
-  // Report channels that match "/^2.0-d.*/i" as dev.
-  if (FindSubstringMatch(value_, kChromeChannelDevPattern) == 0) {
-    channel_name->assign(installer::kChromeChannelDev);
-    return true;
-  }
-  // Report channels that match "/.*x64-dev.*/" as dev.
-  if (value_.find(kChromeChannelDevX64Pattern) != base::string16::npos) {
-    channel_name->assign(installer::kChromeChannelDev);
-    return true;
-  }
-  // Report channels that match "/^1.1-.*/i" as beta.
-  if (FindSubstringMatch(value_, kChromeChannelBetaPattern) == 0) {
-    channel_name->assign(installer::kChromeChannelBeta);
-    return true;
-  }
-  // Report channels that match "/.*x64-beta.*/" as beta.
-  if (value_.find(kChromeChannelBetaX64Pattern) != base::string16::npos) {
-    channel_name->assign(installer::kChromeChannelBeta);
-    return true;
-  }
-
-  // There may be modifiers present. Strip them off and see if we're left
-  // with the empty string (stable channel).
-  base::string16 tmp_value = value_;
-  for (int i = 0; i != NUM_MODIFIERS; ++i) {
-    SetModifier(static_cast<ModifierIndex>(i), false, &tmp_value);
-  }
-  if (tmp_value.empty()) {
-    channel_name->erase();
-    return true;
-  }
-
-  return false;
-}
-
 bool ChannelInfo::IsChrome() const {
   return HasModifier(MOD_CHROME, value_);
 }
 
 bool ChannelInfo::SetChrome(bool value) {
   return SetModifier(MOD_CHROME, value, &value_);
 }
 
 bool ChannelInfo::IsChromeFrame() const {
   return HasModifier(MOD_CHROME_FRAME, value_);
@@ skipping 75 matching lines @@
 
   for (int scan = 0; scan < NUM_MODIFIERS; ++scan) {
     ModifierIndex index = static_cast<ModifierIndex>(scan);
     modified = SetModifier(index, false, &value_) || modified;
   }
 
   return modified;
 }
 
 }  // namespace installer