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

chrome/renderer/chrome_render_process_observer.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/renderer/chrome_render_process_observer.h"
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 86 matching lines @@
       const std::string& mime_type,
       const GURL& url) {
     return ExtensionLocalizationPeer::CreateExtensionLocalizationPeer(
         current_peer, RenderThread::current(), mime_type, url);
   }
 
  private:
   void InformHostOfCacheStats() {
     WebCache::UsageStats stats;
     WebCache::getUsageStats(&stats);
-    RenderThread::current()->Send(new ViewHostMsg_UpdatedCacheStats(stats));
+    RenderThread::current()->Send(new ChromeViewHostMsg_UpdatedCacheStats(
+        stats));
   }
 
   ScopedRunnableMethodFactory<RendererResourceDelegate> method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererResourceDelegate);
 };
 
 class RenderViewContentSettingsSetter : public RenderViewVisitor {
  public:
   RenderViewContentSettingsSetter(const GURL& url,
@@ skipping 280 matching lines @@
     media::InitializeMediaLibrary(media_path);
 }
 
 ChromeRenderProcessObserver::~ChromeRenderProcessObserver() {
 }
 
 bool ChromeRenderProcessObserver::OnControlMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ChromeRenderProcessObserver, message)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetIsIncognitoProcess, OnSetIsIncognitoProcess)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetDefaultContentSettings,
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetIsIncognitoProcess,
+                        OnSetIsIncognitoProcess)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetDefaultContentSettings,
                         OnSetDefaultContentSettings)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetContentSettingsForCurrentURL,
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetContentSettingsForCurrentURL,
                         OnSetContentSettingsForCurrentURL)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetCacheCapacities, OnSetCacheCapacities)
-    IPC_MESSAGE_HANDLER(ViewMsg_ClearCache, OnClearCache)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetFieldTrialGroup, OnSetFieldTrialGroup)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetCacheCapacities, OnSetCacheCapacities)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_ClearCache, OnClearCache)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetFieldTrialGroup, OnSetFieldTrialGroup)
 #if defined(USE_TCMALLOC)
-    IPC_MESSAGE_HANDLER(ViewMsg_GetRendererTcmalloc, OnGetRendererTcmalloc)
-    IPC_MESSAGE_HANDLER(ViewMsg_SetTcmallocHeapProfiling,
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_GetRendererTcmalloc,
+                        OnGetRendererTcmalloc)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetTcmallocHeapProfiling,
                         OnSetTcmallocHeapProfiling)
-    IPC_MESSAGE_HANDLER(ViewMsg_WriteTcmallocHeapProfile,
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_WriteTcmallocHeapProfile,
                         OnWriteTcmallocHeapProfile)
 #endif
-    IPC_MESSAGE_HANDLER(ViewMsg_GetV8HeapStats, OnGetV8HeapStats)
-    IPC_MESSAGE_HANDLER(ViewMsg_GetCacheResourceStats, OnGetCacheResourceStats)
-    IPC_MESSAGE_HANDLER(ViewMsg_PurgeMemory, OnPurgeMemory)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_GetV8HeapStats, OnGetV8HeapStats)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_GetCacheResourceStats,
+                        OnGetCacheResourceStats)
+    IPC_MESSAGE_HANDLER(ChromeViewMsg_PurgeMemory, OnPurgeMemory)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ChromeRenderProcessObserver::WebKitInitialized() {
   WebRuntimeFeatures::enableMediaPlayer(media::IsMediaLibraryInitialized());
 }
 
 void ChromeRenderProcessObserver::OnSetIsIncognitoProcess(
@@ skipping 20 matching lines @@
       min_dead_capacity, max_dead_capacity, capacity);
 }
 
 void ChromeRenderProcessObserver::OnClearCache() {
   WebCache::clear();
 }
 
 void ChromeRenderProcessObserver::OnGetCacheResourceStats() {
   WebCache::ResourceTypeStats stats;
   WebCache::getResourceTypeStats(&stats);
-  Send(new ViewHostMsg_ResourceTypeStats(stats));
+  Send(new ChromeViewHostMsg_ResourceTypeStats(stats));
 }
 
 #if defined(USE_TCMALLOC)
 void ChromeRenderProcessObserver::OnGetRendererTcmalloc() {
   std::string result;
   char buffer[1024 * 32];
   MallocExtension::instance()->GetStats(buffer, sizeof(buffer));
   result.append(buffer);
-  Send(new ViewHostMsg_RendererTcmalloc(result));
+  Send(new ChromeViewHostMsg_RendererTcmalloc(result));
 }
 
 void ChromeRenderProcessObserver::OnSetTcmallocHeapProfiling(
     bool profiling, const std::string& filename_prefix) {
 #if !defined(OS_WIN)
   // TODO(stevenjb): Create MallocExtension wrappers for HeapProfile functions.
   if (profiling)
     HeapProfilerStart(filename_prefix.c_str());
   else
     HeapProfilerStop();
 #endif
 }
 
 void ChromeRenderProcessObserver::OnWriteTcmallocHeapProfile(
     const FilePath::StringType& filename) {
 #if !defined(OS_WIN)
   // TODO(stevenjb): Create MallocExtension wrappers for HeapProfile functions.
   if (!IsHeapProfilerRunning())
     return;
   char* profile = GetHeapProfile();
   if (!profile) {
     LOG(WARNING) << "Unable to get heap profile.";
     return;
   }
   // The render process can not write to a file, so copy the result into
   // a string and pass it to the handler (which runs on the browser host).
   std::string result(profile);
   delete profile;
-  Send(new ViewHostMsg_WriteTcmallocHeapProfile_ACK(filename, result));
+  Send(new ChromeViewHostMsg_WriteTcmallocHeapProfile_ACK(filename, result));
 #endif
 }
 
 #endif
 
 void ChromeRenderProcessObserver::OnSetFieldTrialGroup(
     const std::string& field_trial_name,
     const std::string& group_name) {
   base::FieldTrialList::CreateFieldTrial(field_trial_name, group_name);
 }
 
 void ChromeRenderProcessObserver::OnGetV8HeapStats() {
   v8::HeapStatistics heap_stats;
   v8::V8::GetHeapStatistics(&heap_stats);
-  Send(new ViewHostMsg_V8HeapStats(heap_stats.total_heap_size(),
-                                   heap_stats.used_heap_size()));
+  Send(new ChromeViewHostMsg_V8HeapStats(heap_stats.total_heap_size(),
+                                         heap_stats.used_heap_size()));
 }
 
 void ChromeRenderProcessObserver::OnPurgeMemory() {
   // Clear the object cache (as much as possible; some live objects cannot be
   // freed).
   WebCache::clear();
 
   // Clear the font/glyph cache.
   WebFontCache::clear();
 
@@ skipping 13 matching lines @@
   }
 
 #if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
   // Tell tcmalloc to release any free pages it's still holding.
   MallocExtension::instance()->ReleaseFreeMemory();
 #endif
 
   if (client_)
     client_->OnPurgeMemory();
 }