Clean up some ifdefs around Win Aura.

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>
 
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 145 matching lines @@
   { 39, IDR_MENU_DROPARROW, NULL },
   { 40, IDR_THROBBER, NULL },
   { 41, IDR_THROBBER_WAITING, NULL },
   { 42, IDR_THROBBER_LIGHT, NULL },
   { 43, IDR_TOOLBAR_BEZEL_HOVER, NULL },
   { 44, IDR_TOOLBAR_BEZEL_PRESSED, NULL },
   { 45, IDR_TOOLS_BAR, NULL },
 };
 const size_t kPersistingImagesLength = arraysize(kPersistingImages);
 
-#if defined(OS_WIN) && defined(USE_AURA)
-// Persistent theme ids for Windows AURA.
+#if defined(OS_WIN)
+// Persistent theme ids for Windows.
 const int PRS_THEME_FRAME_WIN = 100;
 const int PRS_THEME_FRAME_INACTIVE_WIN = 101;
 const int PRS_THEME_FRAME_INCOGNITO_WIN = 102;
 const int PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN = 103;
 const int PRS_THEME_TOOLBAR_WIN = 104;
 const int PRS_THEME_TAB_BACKGROUND_WIN = 105;
 const int PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN = 106;
 
 // Persistent theme to resource id mapping for Windows AURA.
 PersistingImagesTable kPersistingImagesWinDesktopAura[] = {
@@ skipping 37 matching lines @@
 }
 
 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(OS_WIN) && defined(USE_AURA)
+#if defined(OS_WIN)
     for (size_t i = 0; i < kPersistingImagesWinDesktopAuraLength; ++i) {
       int idr = kPersistingImagesWinDesktopAura[i].idr_id;
       int prs_id = kPersistingImagesWinDesktopAura[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;
 }
@@ skipping 99 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(OS_WIN) && defined(USE_AURA)
+#if defined(OS_WIN)
   { PRS_THEME_FRAME_WIN, ThemeProperties::TINT_FRAME },
   { PRS_THEME_FRAME_INACTIVE_WIN, ThemeProperties::TINT_FRAME_INACTIVE },
   { PRS_THEME_FRAME_INCOGNITO_WIN, ThemeProperties::TINT_FRAME_INCOGNITO },
   { PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN,
     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(OS_WIN) && defined(USE_AURA)
+#if defined(OS_WIN)
   { PRS_THEME_TAB_BACKGROUND_WIN, PRS_THEME_FRAME_WIN },
   { PRS_THEME_TAB_BACKGROUND_INCOGNITO_WIN, PRS_THEME_FRAME_INCOGNITO_WIN },
 #endif
 };
 
 struct CropEntry {
   int prs_id;
 
   // The maximum useful height of the image at |prs_id|.
   int max_height;
@@ skipping 13 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(OS_WIN) && defined(USE_AURA)
+#if defined(OS_WIN)
   { PRS_THEME_TOOLBAR_WIN, 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[] = {
@@ skipping 359 matching lines @@
 
 // static
 void BrowserThemePack::GetThemeableImageIDRs(std::set<int>* result) {
   if (!result)
     return;
 
   result->clear();
   for (size_t i = 0; i < kPersistingImagesLength; ++i)
     result->insert(kPersistingImages[i].idr_id);
 
-#if defined(OS_WIN) && defined(USE_AURA)
+#if defined(OS_WIN)
   for (size_t i = 0; i < kPersistingImagesWinDesktopAuraLength; ++i)
     result->insert(kPersistingImagesWinDesktopAura[i].idr_id);
 #endif
 }
 
 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));
@@ skipping 420 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(OS_WIN) && defined(USE_AURA)
+#if defined(OS_WIN)
   id = GetPersistentIDByNameHelper(image_name,
                                    kPersistingImagesWinDesktopAura,
                                    kPersistingImagesWinDesktopAuraLength);
   if (id != -1)
     (*file_paths)[id][scale_factor] = image_path;
 #endif
 }
 
 void BrowserThemePack::BuildSourceImagesArray(const FilePathMap& file_paths) {
   std::vector<int> ids;
@@ skipping 107 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(OS_WIN) && defined(USE_AURA)
+#if defined(OS_WIN)
     if (prs_id == PRS_THEME_FRAME_INCOGNITO_INACTIVE_WIN) {
       prs_base_id = images->count(PRS_THEME_FRAME_INCOGNITO_WIN) ?
                     PRS_THEME_FRAME_INCOGNITO_WIN : PRS_THEME_FRAME_WIN;
     } else if (prs_id == PRS_THEME_FRAME_INACTIVE_WIN) {
       prs_base_id = PRS_THEME_FRAME_WIN;
     } else if (prs_id == PRS_THEME_FRAME_INCOGNITO_WIN &&
                 !images->count(PRS_THEME_FRAME_INCOGNITO_WIN)) {
       prs_base_id = PRS_THEME_FRAME_WIN;
     }
 #endif
@@ skipping 10 matching lines @@
         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(OS_WIN) && defined(USE_AURA)
+#if defined(OS_WIN)
       if (images->count(PRS_THEME_FRAME_WIN)) {
 #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 {
@@ skipping 223 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);
   }
 }