Prefix all IPC messages used by src\chrome with Chrome. For e.g ChromeViewMsg_, ChromeViewHostMsg...

chrome/utility/chrome_content_utility_client.cc

 // Copyright (c) 2011 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/utility/chrome_content_utility_client.h"
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 44 matching lines @@
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   std::string lang = command_line->GetSwitchValueASCII(switches::kLang);
   if (!lang.empty())
     extension_l10n_util::SetProcessLocale(lang);
 }
 
 bool ChromeContentUtilityClient::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeContentUtilityClient, message)
-    IPC_MESSAGE_HANDLER(UtilityMsg_UnpackExtension, OnUnpackExtension)
-    IPC_MESSAGE_HANDLER(UtilityMsg_UnpackWebResource, OnUnpackWebResource)
-    IPC_MESSAGE_HANDLER(UtilityMsg_ParseUpdateManifest, OnParseUpdateManifest)
-    IPC_MESSAGE_HANDLER(UtilityMsg_DecodeImage, OnDecodeImage)
-    IPC_MESSAGE_HANDLER(UtilityMsg_DecodeImageBase64, OnDecodeImageBase64)
-    IPC_MESSAGE_HANDLER(UtilityMsg_RenderPDFPagesToMetafile,
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_UnpackExtension, OnUnpackExtension)
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_UnpackWebResource,
+                        OnUnpackWebResource)
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseUpdateManifest,
+                        OnParseUpdateManifest)
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_DecodeImage, OnDecodeImage)
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_DecodeImageBase64, OnDecodeImageBase64)
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_RenderPDFPagesToMetafile,
                         OnRenderPDFPagesToMetafile)
-    IPC_MESSAGE_HANDLER(UtilityMsg_ParseJSON, OnParseJSON)
-    IPC_MESSAGE_HANDLER(UtilityMsg_GetPrinterCapsAndDefaults,
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ParseJSON, OnParseJSON)
+    IPC_MESSAGE_HANDLER(ChromeUtilityMsg_GetPrinterCapsAndDefaults,
                         OnGetPrinterCapsAndDefaults)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 bool ChromeContentUtilityClient::Send(IPC::Message* message) {
   return UtilityThread::current()->Send(message);
 }
 
 void ChromeContentUtilityClient::OnUnpackExtension(
     const FilePath& extension_path) {
   ExtensionUnpacker unpacker(extension_path);
   if (unpacker.Run() && unpacker.DumpImagesToFile() &&
       unpacker.DumpMessageCatalogsToFile()) {
-    Send(new UtilityHostMsg_UnpackExtension_Succeeded(
+    Send(new ChromeUtilityHostMsg_UnpackExtension_Succeeded(
         *unpacker.parsed_manifest()));
   } else {
-    Send(new UtilityHostMsg_UnpackExtension_Failed(unpacker.error_message()));
+    Send(new ChromeUtilityHostMsg_UnpackExtension_Failed(
+        unpacker.error_message()));
   }
 
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 void ChromeContentUtilityClient::OnUnpackWebResource(
     const std::string& resource_data) {
   // Parse json data.
   // TODO(mrc): Add the possibility of a template that controls parsing, and
   // the ability to download and verify images.
   WebResourceUnpacker unpacker(resource_data);
   if (unpacker.Run()) {
-    Send(new UtilityHostMsg_UnpackWebResource_Succeeded(
+    Send(new ChromeUtilityHostMsg_UnpackWebResource_Succeeded(
         *unpacker.parsed_json()));
   } else {
-    Send(new UtilityHostMsg_UnpackWebResource_Failed(
+    Send(new ChromeUtilityHostMsg_UnpackWebResource_Failed(
         unpacker.error_message()));
   }
 
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 void ChromeContentUtilityClient::OnParseUpdateManifest(const std::string& xml) {
   UpdateManifest manifest;
   if (!manifest.Parse(xml)) {
-    Send(new UtilityHostMsg_ParseUpdateManifest_Failed(manifest.errors()));
+    Send(new ChromeUtilityHostMsg_ParseUpdateManifest_Failed(
+        manifest.errors()));
   } else {
-    Send(new UtilityHostMsg_ParseUpdateManifest_Succeeded(manifest.results()));
+    Send(new ChromeUtilityHostMsg_ParseUpdateManifest_Succeeded(
+        manifest.results()));
   }
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 void ChromeContentUtilityClient::OnDecodeImage(
     const std::vector<unsigned char>& encoded_data) {
   webkit_glue::ImageDecoder decoder;
   const SkBitmap& decoded_image = decoder.Decode(&encoded_data[0],
                                                  encoded_data.size());
   if (decoded_image.empty()) {
-    Send(new UtilityHostMsg_DecodeImage_Failed());
+    Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
   } else {
-    Send(new UtilityHostMsg_DecodeImage_Succeeded(decoded_image));
+    Send(new ChromeUtilityHostMsg_DecodeImage_Succeeded(decoded_image));
   }
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 void ChromeContentUtilityClient::OnDecodeImageBase64(
     const std::string& encoded_string) {
   std::string decoded_string;
 
   if (!base::Base64Decode(encoded_string, &decoded_string)) {
-    Send(new UtilityHostMsg_DecodeImage_Failed());
+    Send(new ChromeUtilityHostMsg_DecodeImage_Failed());
     return;
   }
 
   std::vector<unsigned char> decoded_vector(decoded_string.size());
   for (size_t i = 0; i < decoded_string.size(); ++i) {
     decoded_vector[i] = static_cast<unsigned char>(decoded_string[i]);
   }
 
   OnDecodeImage(decoded_vector);
 }
 
 void ChromeContentUtilityClient::OnRenderPDFPagesToMetafile(
     base::PlatformFile pdf_file,
     const FilePath& metafile_path,
     const gfx::Rect& render_area,
     int render_dpi,
     const std::vector<printing::PageRange>& page_ranges) {
   bool succeeded = false;
 #if defined(OS_WIN)
   int highest_rendered_page_number = 0;
   succeeded = RenderPDFToWinMetafile(pdf_file,
                                      metafile_path,
                                      render_area,
                                      render_dpi,
                                      page_ranges,
                                      &highest_rendered_page_number);
   if (succeeded) {
-    Send(new UtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(
+    Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Succeeded(
         highest_rendered_page_number));
   }
 #endif  // defined(OS_WIN)
   if (!succeeded) {
-    Send(new UtilityHostMsg_RenderPDFPagesToMetafile_Failed());
+    Send(new ChromeUtilityHostMsg_RenderPDFPagesToMetafile_Failed());
   }
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 #if defined(OS_WIN)
 // Exported by pdf.dll
 typedef bool (*RenderPDFPageToDCProc)(
     const unsigned char* pdf_buffer, int buffer_size, int page_number, HDC dc,
     int dpi_x, int dpi_y, int bounds_origin_x, int bounds_origin_y,
     int bounds_width, int bounds_height, bool fit_to_bounds,
@@ skipping 24 matching lines @@
 DWORD WINAPI UtilityProcess_GetFontDataPatch(
     HDC hdc, DWORD table, DWORD offset, LPVOID buffer, DWORD length) {
   int rv = GetFontData(hdc, table, offset, buffer, length);
   if (rv == GDI_ERROR && hdc) {
     HFONT font = static_cast<HFONT>(GetCurrentObject(hdc, OBJ_FONT));
 
     LOGFONT logfont;
     if (GetObject(font, sizeof(LOGFONT), &logfont)) {
       std::vector<char> font_data;
       if (UtilityThread::current()->Send(
-              new UtilityHostMsg_PreCacheFont(logfont)))
+              new ChromeUtilityHostMsg_PreCacheFont(logfont)))
         rv = GetFontData(hdc, table, offset, buffer, length);
     }
   }
   return rv;
 }
 
 bool ChromeContentUtilityClient::RenderPDFToWinMetafile(
     base::PlatformFile pdf_file,
     const FilePath& metafile_path,
     const gfx::Rect& render_area,
@@ skipping 86 matching lines @@
 
 
 void ChromeContentUtilityClient::OnParseJSON(const std::string& json) {
   int error_code;
   std::string error;
   Value* value =
       base::JSONReader::ReadAndReturnError(json, false, &error_code, &error);
   if (value) {
     ListValue wrapper;
     wrapper.Append(value);
-    Send(new UtilityHostMsg_ParseJSON_Succeeded(wrapper));
+    Send(new ChromeUtilityHostMsg_ParseJSON_Succeeded(wrapper));
   } else {
-    Send(new UtilityHostMsg_ParseJSON_Failed(error));
+    Send(new ChromeUtilityHostMsg_ParseJSON_Failed(error));
   }
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 void ChromeContentUtilityClient::OnGetPrinterCapsAndDefaults(
     const std::string& printer_name) {
   scoped_refptr<printing::PrintBackend> print_backend =
       printing::PrintBackend::CreateInstance(NULL);
   printing::PrinterCapsAndDefaults printer_info;
   if (print_backend->GetPrinterCapsAndDefaults(printer_name, &printer_info)) {
-    Send(new UtilityHostMsg_GetPrinterCapsAndDefaults_Succeeded(printer_name,
-                                                                printer_info));
+    Send(new ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Succeeded(
+        printer_name, printer_info));
   } else {
-    Send(new UtilityHostMsg_GetPrinterCapsAndDefaults_Failed(printer_name));
+    Send(new ChromeUtilityHostMsg_GetPrinterCapsAndDefaults_Failed(
+        printer_name));
   }
   UtilityThread::current()->ReleaseProcessIfNeeded();
 }
 
 }  // namespace chrome