Remove win aura theme references

chrome/browser/themes/browser_theme_pack.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/themes/browser_theme_pack.h"
 
 #include <limits.h>
 #include <stddef.h>
 
 #include <limits>
@@ skipping 69 matching lines @@
 const int PRS_THEME_TAB_BACKGROUND_V = 8;
 const int PRS_THEME_NTP_BACKGROUND = 9;
 const int PRS_THEME_FRAME_OVERLAY = 10;
 const int PRS_THEME_FRAME_OVERLAY_INACTIVE = 11;
 const int PRS_THEME_BUTTON_BACKGROUND = 12;
 const int PRS_THEME_NTP_ATTRIBUTION = 13;
 const int PRS_THEME_WINDOW_CONTROL_BACKGROUND = 14;
 
 struct PersistingImagesTable {
   // A non-changing integer ID meant to be saved in theme packs. This ID must
   // not change between versions of chrome.

[Evan Stade, 2016/02/09 00:11:02]

does this comment mean it's not OK to just delete PRS_*_DESKTOP?

[pkotwicz, 2016/02/09 00:23:54]

This comment indicates that you must change kThemePackVersion. This will force
the theme to be re-extracted from the .crx.

[Evan Stade, 2016/02/09 00:31:46]

Done.

   int persistent_id;
 
   // The IDR that depends on the whims of GRIT and therefore changes whenever
   // someone adds a new resource.
   int idr_id;
 
   // String to check for when parsing theme manifests or NULL if this isn't
   // supposed to be changeable by the user.
   const char* const key;
 };
@@ skipping 69 matching lines @@
     {36, IDR_TOOLS, NULL},
     {37, IDR_TOOLS_H, NULL},
     {38, IDR_TOOLS_P, NULL},
     {39, IDR_MENU_DROPARROW, NULL},
     {40, IDR_TOOLBAR_BEZEL_HOVER, NULL},
     {41, IDR_TOOLBAR_BEZEL_PRESSED, NULL},
     {42, IDR_TOOLS_BAR, NULL},
 };
 const size_t kPersistingImagesLength = arraysize(kPersistingImages);
 
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-// Persistent theme ids for Windows.
-const int PRS_THEME_FRAME_DESKTOP = 100;
-const int PRS_THEME_FRAME_INACTIVE_DESKTOP = 101;
-const int PRS_THEME_FRAME_INCOGNITO_DESKTOP = 102;
-const int PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP = 103;
-const int PRS_THEME_TOOLBAR_DESKTOP = 104;
-const int PRS_THEME_TAB_BACKGROUND_DESKTOP = 105;
-const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_DESKTOP = 106;
-
-// Persistent theme to resource id mapping for Windows AURA.
-PersistingImagesTable kPersistingImagesDesktopAura[] = {
-  { PRS_THEME_FRAME_DESKTOP, IDR_THEME_FRAME_DESKTOP,
-    "theme_frame" },
-  { PRS_THEME_FRAME_INACTIVE_DESKTOP, IDR_THEME_FRAME_INACTIVE_DESKTOP,
-    "theme_frame_inactive" },
-  { PRS_THEME_FRAME_INCOGNITO_DESKTOP, IDR_THEME_FRAME_INCOGNITO_DESKTOP,
-    "theme_frame_incognito" },
-  { PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP,
-    IDR_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP,
-    "theme_frame_incognito_inactive" },
-  { PRS_THEME_TOOLBAR_DESKTOP, IDR_THEME_TOOLBAR_DESKTOP,
-    "theme_toolbar" },
-  { PRS_THEME_TAB_BACKGROUND_DESKTOP, IDR_THEME_TAB_BACKGROUND_DESKTOP,
-    "theme_tab_background" },
-  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_DESKTOP,
-    IDR_THEME_TAB_BACKGROUND_INCOGNITO_DESKTOP,
-    "theme_tab_background_incognito" },
-};
-const size_t kPersistingImagesDesktopAuraLength =
-    arraysize(kPersistingImagesDesktopAura);
-#endif
-
 int GetPersistentIDByNameHelper(const std::string& key,
                                 const PersistingImagesTable* image_table,
                                 size_t image_table_size) {
   for (size_t i = 0; i < image_table_size; ++i) {
     if (image_table[i].key &&
         base::LowerCaseEqualsASCII(key, image_table[i].key)) {
       return image_table[i].persistent_id;
     }
   }
   return -1;
 }
 
 int GetPersistentIDByName(const std::string& key) {
   return GetPersistentIDByNameHelper(key,
                                      kPersistingImages,
                                      kPersistingImagesLength);
 }
 
 int GetPersistentIDByIDR(int idr) {
   static std::map<int,int>* lookup_table = new std::map<int,int>();
   if (lookup_table->empty()) {
     for (size_t i = 0; i < kPersistingImagesLength; ++i) {
       int idr = kPersistingImages[i].idr_id;
       int prs_id = kPersistingImages[i].persistent_id;
       (*lookup_table)[idr] = prs_id;
     }
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-    for (size_t i = 0; i < kPersistingImagesDesktopAuraLength; ++i) {
-      int idr = kPersistingImagesDesktopAura[i].idr_id;
-      int prs_id = kPersistingImagesDesktopAura[i].persistent_id;
-      (*lookup_table)[idr] = prs_id;
-    }
-#endif
   }
   std::map<int,int>::iterator it = lookup_table->find(idr);
   return (it == lookup_table->end()) ? -1 : it->second;
 }
 
 // Returns the maximum persistent id.
 int GetMaxPersistentId() {
   static int max_prs_id = -1;
   if (max_prs_id == -1) {
     for (size_t i = 0; i < kPersistingImagesLength; ++i) {
       if (kPersistingImages[i].persistent_id > max_prs_id)
         max_prs_id = kPersistingImages[i].persistent_id;
     }
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-    for (size_t i = 0; i < kPersistingImagesDesktopAuraLength; ++i) {
-      if (kPersistingImagesDesktopAura[i].persistent_id > max_prs_id)
-        max_prs_id = kPersistingImagesDesktopAura[i].persistent_id;
-    }
-#endif
   }
   return max_prs_id;
 }
 
 // Returns true if the scales in |input| match those in |expected|.
 // The order must match as the index is used in determining the raw id.
 bool InputScalesValid(const base::StringPiece& input,
                       const std::vector<ui::ScaleFactor>& expected) {
   size_t scales_size = static_cast<size_t>(input.size() / sizeof(float));
   if (scales_size != expected.size())
@@ skipping 92 matching lines @@
 // tint ID that should maybe be applied to it.
 IntToIntTable kFrameTintMap[] = {
   { PRS_THEME_FRAME, ThemeProperties::TINT_FRAME },
   { PRS_THEME_FRAME_INACTIVE, ThemeProperties::TINT_FRAME_INACTIVE },
   { PRS_THEME_FRAME_OVERLAY, ThemeProperties::TINT_FRAME },
   { PRS_THEME_FRAME_OVERLAY_INACTIVE,
     ThemeProperties::TINT_FRAME_INACTIVE },
   { PRS_THEME_FRAME_INCOGNITO, ThemeProperties::TINT_FRAME_INCOGNITO },
   { PRS_THEME_FRAME_INCOGNITO_INACTIVE,
     ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-  { PRS_THEME_FRAME_DESKTOP, ThemeProperties::TINT_FRAME },
-  { PRS_THEME_FRAME_INACTIVE_DESKTOP, ThemeProperties::TINT_FRAME_INACTIVE },
-  { PRS_THEME_FRAME_INCOGNITO_DESKTOP, ThemeProperties::TINT_FRAME_INCOGNITO },
-  { PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP,
-    ThemeProperties::TINT_FRAME_INCOGNITO_INACTIVE },
-#endif
 };
 
 // Mapping used in GenerateTabBackgroundImages() to associate what frame image
 // goes with which tab background.
 IntToIntTable kTabBackgroundMap[] = {
   { PRS_THEME_TAB_BACKGROUND, PRS_THEME_FRAME },
   { PRS_THEME_TAB_BACKGROUND_INCOGNITO, PRS_THEME_FRAME_INCOGNITO },
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-  { PRS_THEME_TAB_BACKGROUND_DESKTOP, PRS_THEME_FRAME_DESKTOP },
-  { PRS_THEME_TAB_BACKGROUND_INCOGNITO_DESKTOP,
-    PRS_THEME_FRAME_INCOGNITO_DESKTOP },
-#endif
 };
 
 struct CropEntry {
   int prs_id;
 
   // The maximum useful height of the image at |prs_id|.
   int max_height;
 
   // Whether cropping the image at |prs_id| should be skipped on OSes which
   // have a frame border to the left and right of the web contents.
@@ skipping 10 matching lines @@
 struct CropEntry kImagesToCrop[] = {
   { PRS_THEME_FRAME, 120, true },
   { PRS_THEME_FRAME_INACTIVE, 120, true },
   { PRS_THEME_FRAME_INCOGNITO, 120, true },
   { PRS_THEME_FRAME_INCOGNITO_INACTIVE, 120, true },
   { PRS_THEME_FRAME_OVERLAY, 120, true },
   { PRS_THEME_FRAME_OVERLAY_INACTIVE, 120, true },
   { PRS_THEME_TOOLBAR, 200, false },
   { PRS_THEME_BUTTON_BACKGROUND, 60, false },
   { PRS_THEME_WINDOW_CONTROL_BACKGROUND, 50, false },
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-  { PRS_THEME_TOOLBAR_DESKTOP, 200, false }
-#endif
 };
 
 
 // A list of images that don't need tinting or any other modification and can
 // be byte-copied directly into the finished DataPack. This should contain the
 // persistent IDs for all themeable image IDs that aren't in kFrameTintMap,
 // kTabBackgroundMap or kImagesToCrop.
 const int kPreloadIDs[] = {
   PRS_THEME_NTP_BACKGROUND,
   PRS_THEME_NTP_ATTRIBUTION,
@@ skipping 347 matching lines @@
   }
   return pack;
 }
 
 // static
 bool BrowserThemePack::IsPersistentImageID(int id) {
   for (size_t i = 0; i < kPersistingImagesLength; ++i)
     if (kPersistingImages[i].idr_id == id)
       return true;
 
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-  for (size_t i = 0; i < kPersistingImagesDesktopAuraLength; ++i)
-    if (kPersistingImagesDesktopAura[i].idr_id == id)
-      return true;
-#endif
-
   return false;
 }
 
 bool BrowserThemePack::WriteToDisk(const base::FilePath& path) const {
   // Add resources for each of the property arrays.
   RawDataForWriting resources;
   resources[kHeaderID] = base::StringPiece(
       reinterpret_cast<const char*>(header_), sizeof(BrowserThemePackHeader));
   resources[kTintsID] = base::StringPiece(
       reinterpret_cast<const char*>(tints_),
@@ skipping 423 matching lines @@
   }
 }
 
 void BrowserThemePack::AddFileAtScaleToMap(const std::string& image_name,
                                            ui::ScaleFactor scale_factor,
                                            const base::FilePath& image_path,
                                            FilePathMap* file_paths) const {
   int id = GetPersistentIDByName(image_name);
   if (id != -1)
     (*file_paths)[id][scale_factor] = image_path;
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-  id = GetPersistentIDByNameHelper(image_name,
-                                   kPersistingImagesDesktopAura,
-                                   kPersistingImagesDesktopAuraLength);
-  if (id != -1)
-    (*file_paths)[id][scale_factor] = image_path;
-#endif
 }
 
 void BrowserThemePack::BuildSourceImagesArray(const FilePathMap& file_paths) {
   std::vector<int> ids;
   for (FilePathMap::const_iterator it = file_paths.begin();
        it != file_paths.end(); ++it) {
     ids.push_back(it->first);
   }
 
   source_images_ = new int[ids.size() + 1];
@@ skipping 101 matching lines @@
   ImageCache temp_output;
 
   for (size_t i = 0; i < arraysize(kFrameTintMap); ++i) {
     int prs_id = kFrameTintMap[i].key;
     gfx::Image frame;
     // If there's no frame image provided for the specified id, then load
     // the default provided frame. If that's not provided, skip this whole
     // thing and just use the default images.
     int prs_base_id = 0;
 
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-    if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP) {
-      prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO_DESKTOP) ?
-                    PRS_THEME_FRAME_INCOGNITO_DESKTOP : PRS_THEME_FRAME_DESKTOP;
-    } else if (prs_id == PRS_THEME_FRAME_INACTIVE_DESKTOP) {
-      prs_base_id = PRS_THEME_FRAME_DESKTOP;
-    } else if (prs_id == PRS_THEME_FRAME_INCOGNITO_DESKTOP &&
-                !images->count(PRS_THEME_FRAME_INCOGNITO_DESKTOP)) {
-      prs_base_id = PRS_THEME_FRAME_DESKTOP;
-    }
-#endif
     if (!prs_base_id) {
       if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE) {
         prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO) ?
                       PRS_THEME_FRAME_INCOGNITO : PRS_THEME_FRAME;
       } else if (prs_id == PRS_THEME_FRAME_OVERLAY_INACTIVE) {
         prs_base_id = PRS_THEME_FRAME_OVERLAY;
       } else if (prs_id == PRS_THEME_FRAME_INACTIVE) {
         prs_base_id = PRS_THEME_FRAME;
       } else if (prs_id == PRS_THEME_FRAME_INCOGNITO &&
                  !images->count(PRS_THEME_FRAME_INCOGNITO)) {
         prs_base_id = PRS_THEME_FRAME;
       } else {
         prs_base_id = prs_id;
       }
     }
     if (images->count(prs_id)) {
       frame = (*images)[prs_id];
     } else if (prs_base_id != prs_id && images->count(prs_base_id)) {
       frame = (*images)[prs_base_id];
     } else if (prs_base_id == PRS_THEME_FRAME_OVERLAY) {
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-      if (images->count(PRS_THEME_FRAME_DESKTOP)) {
-#else
       if (images->count(PRS_THEME_FRAME)) {
-#endif
         // If there is no theme overlay, don't tint the default frame,
         // because it will overwrite the custom frame image when we cache and
         // reload from disk.
         frame = gfx::Image();
       }
     } else {
       // If the theme doesn't specify an image, then apply the tint to
       // the default frame.
       frame = rb.GetImageNamed(IDR_THEME_FRAME);
-#if defined(USE_ASH) && !defined(OS_CHROMEOS)
-      if (prs_id >= PRS_THEME_FRAME_DESKTOP &&
-          prs_id <= PRS_THEME_FRAME_INCOGNITO_INACTIVE_DESKTOP) {
-        frame = rb.GetImageNamed(IDR_THEME_FRAME_DESKTOP);
-      }
-#endif
     }
     if (!frame.IsEmpty()) {
       temp_output[prs_id] = CreateHSLShiftedImage(
           frame, GetTintInternal(kFrameTintMap[i].value));
     }
   }
   MergeImageCaches(temp_output, images);
 }
 
 void BrowserThemePack::CreateTintedButtons(
@@ skipping 202 matching lines @@
                                            false,
                                            &bitmap_data)) {
       NOTREACHED() << "Unable to encode theme image for prs_id="
                    << prs_id << " for scale_factor=" << scale_factors_[i];
       break;
     }
     image_memory_[scaled_raw_id] =
         base::RefCountedBytes::TakeVector(&bitmap_data);
   }
 }