Clear RenderThread of any Chrome specific code, and move a bunch of stuff out of RenderView.

content/renderer/render_thread.h

 // 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.
 
 #ifndef CONTENT_RENDERER_RENDER_THREAD_H_
 #define CONTENT_RENDERER_RENDER_THREAD_H_
 #pragma once
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/observer_list.h"
 #include "base/shared_memory.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "build/build_config.h"
 #include "content/common/child_thread.h"
 #include "content/common/css_colors.h"
 #include "content/common/gpu_process_launch_causes.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ui/gfx/native_widget_types.h"
 
 class AppCacheDispatcher;
-class CookieMessageFilter;
 class DBMessageFilter;
 class FilePath;
 class GpuChannelHost;
 class IndexedDBDispatcher;
 class RendererHistogram;
 class RendererHistogramSnapshots;
 class RenderProcessObserver;
 class RendererNetPredictor;
 class RendererWebKitClientImpl;
 class SkBitmap;
 class WebDatabaseObserverImpl;
 
-struct ContentSettings;
 struct RendererPreferences;
 struct DOMStorageMsg_Event_Params;
 struct GPUInfo;
 struct ViewMsg_New_Params;
 struct WebPreferences;
 
 namespace base {
 class MessageLoopProxy;
 class Thread;
 }
@@ skipping 50 matching lines @@
   // These methods normally get delegated to a MessageRouter.
   virtual void AddRoute(int32 routing_id, IPC::Channel::Listener* listener) = 0;
   virtual void RemoveRoute(int32 routing_id) = 0;
 
   virtual void AddFilter(IPC::ChannelProxy::MessageFilter* filter) = 0;
   virtual void RemoveFilter(IPC::ChannelProxy::MessageFilter* filter) = 0;
 
   // Called by a RenderWidget when it is hidden or restored.
   virtual void WidgetHidden() = 0;
   virtual void WidgetRestored() = 0;
-
-  // True if this process is running in an incognito profile.
-  virtual bool IsIncognitoProcess() const = 0;
 };
 
 // The RenderThread class represents a background thread where RenderView
 // instances live.  The RenderThread supports an API that is used by its
 // consumer to talk indirectly to the RenderViews and supporting objects.
 // Likewise, it provides an API for the RenderViews to talk back to the main
 // process (i.e., their corresponding TabContents).
 //
 // Most of the communication occurs in the form of IPC messages.  They are
 // routed to the RenderThread according to the routing IDs of the messages.
@@ skipping 20 matching lines @@
   static int32 RoutingIDForCurrentContext();
 
   // Overridden from RenderThreadBase.
   virtual bool Send(IPC::Message* msg);
   virtual void AddRoute(int32 routing_id, IPC::Channel::Listener* listener);
   virtual void RemoveRoute(int32 routing_id);
   virtual void AddFilter(IPC::ChannelProxy::MessageFilter* filter);
   virtual void RemoveFilter(IPC::ChannelProxy::MessageFilter* filter);
   virtual void WidgetHidden();
   virtual void WidgetRestored();
-  virtual bool IsIncognitoProcess() const;
 
   void AddObserver(RenderProcessObserver* observer);
   void RemoveObserver(RenderProcessObserver* observer);
 
   // These methods modify how the next message is sent.  Normally, when sending
   // a synchronous message that runs a nested message loop, we need to suspend
   // callbacks into WebKit.  This involves disabling timers and deferring
   // resource loads.  However, there are exceptions when we need to customize
   // the behavior.
   void DoNotSuspendWebKitSharedTimer();
@@ skipping 77 matching lines @@
 
   // Registers the given V8 extension with WebKit.
   void RegisterExtension(v8::Extension* extension);
 
  private:
   virtual bool OnControlMessageReceived(const IPC::Message& msg);
 
   void Init();
 
   void OnSetZoomLevelForCurrentURL(const GURL& url, double zoom_level);
-  void OnSetContentSettingsForCurrentURL(
-      const GURL& url, const ContentSettings& content_settings);
   void OnDOMStorageEvent(const DOMStorageMsg_Event_Params& params);
   void OnSetNextPageID(int32 next_page_id);
-  void OnSetIsIncognitoProcess(bool is_incognito_process);
   void OnSetCSSColors(const std::vector<CSSColors::CSSColorMapping>& colors);
   void OnCreateNewView(const ViewMsg_New_Params& params);
   void OnTransferBitmap(const SkBitmap& bitmap, int resource_id);
-  void OnSetCacheCapacities(size_t min_dead_capacity,
-                            size_t max_dead_capacity,
-                            size_t capacity);
-  void OnClearCache();
-  void OnGetCacheResourceStats();
-
-  // Send tcmalloc info to browser.
-  void OnGetRendererTcmalloc();
-  void OnGetV8HeapStats();
-
-  void OnPurgeMemory();
   void OnPurgePluginListCache(bool reload_pages);
-
   void OnGpuChannelEstablished(const IPC::ChannelHandle& channel_handle,
                                base::ProcessHandle renderer_process_for_gpu,
                                const GPUInfo& gpu_info);
-
   void OnGetAccessibilityTree();
 
   // We initialize WebKit as late as possible.
   void EnsureWebKitInitialized();
 
   // These objects live solely on the render thread.
   scoped_ptr<ScopedRunnableMethodFactory<RenderThread> > task_factory_;
   scoped_ptr<AppCacheDispatcher> appcache_dispatcher_;
   scoped_ptr<IndexedDBDispatcher> indexed_db_dispatcher_;
   scoped_ptr<RendererWebKitClientImpl> webkit_client_;
   scoped_ptr<WebKit::WebStorageEventDispatcher> dom_storage_event_dispatcher_;
 
   // Used on the renderer and IPC threads.
   scoped_refptr<DBMessageFilter> db_message_filter_;
-  scoped_refptr<CookieMessageFilter> cookie_message_filter_;
 
   // Used on multiple script execution context threads.
   scoped_ptr<WebDatabaseObserverImpl> web_database_observer_impl_;
 
   // If true, then a GetPlugins call is allowed to rescan the disk.
   bool plugin_refresh_allowed_;
 
   // The count of RenderWidgets running through this thread.
   int widget_count_;
 
   // The count of hidden RenderWidgets running through this thread.
   int hidden_widget_count_;
 
   // The current value of the idle notification timer delay.
   double idle_notification_delay_in_s_;
 
-  // True if this renderer is incognito.
-  bool is_incognito_process_;
-
   bool suspend_webkit_shared_timer_;
   bool notify_webkit_of_modal_loop_;
 
   // Timer that periodically calls IdleHandler.
   base::RepeatingTimer<RenderThread> idle_timer_;
 
   // The channel from the renderer process to the GPU process.
   scoped_refptr<GpuChannelHost> gpu_channel_;
 
   // A lazily initiated thread on which file operations are run.
   scoped_ptr<base::Thread> file_thread_;
 
   // Map of registered v8 extensions. The key is the extension name.
   std::set<std::string> v8_extensions_;
 
   ObserverList<RenderProcessObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderThread);
 };
 
 #endif  // CONTENT_RENDERER_RENDER_THREAD_H_