Home | History | Annotate | Download | only in renderer_host 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
      6 
      7 #include <string>
      8 
      9 #include "base/bind.h"
     10 #include "base/bind_helpers.h"
     11 #include "base/metrics/histogram.h"
     12 #include "chrome/browser/chrome_notification_types.h"
     13 #include "chrome/browser/content_settings/cookie_settings.h"
     14 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
     15 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
     16 #include "chrome/browser/net/predictor.h"
     17 #include "chrome/browser/profiles/profile.h"
     18 #include "chrome/browser/profiles/profile_manager.h"
     19 #include "chrome/common/extensions/api/i18n/default_locale_handler.h"
     20 #include "chrome/common/render_messages.h"
     21 #include "components/web_cache/browser/web_cache_manager.h"
     22 #include "content/public/browser/notification_service.h"
     23 #include "content/public/browser/render_process_host.h"
     24 
     25 #if defined(ENABLE_EXTENSIONS)
     26 #include "extensions/browser/guest_view/web_view/web_view_permission_helper.h"
     27 #include "extensions/browser/guest_view/web_view/web_view_renderer_state.h"
     28 #endif
     29 
     30 #if defined(ENABLE_TASK_MANAGER)
     31 #include "chrome/browser/task_manager/task_manager.h"
     32 #endif
     33 
     34 #if defined(USE_TCMALLOC)
     35 #include "chrome/browser/browser_about_handler.h"
     36 #endif
     37 
     38 using content::BrowserThread;
     39 using blink::WebCache;
     40 
     41 namespace {
     42 
     43 const uint32 kFilteredMessageClasses[] = {
     44   ChromeMsgStart,
     45 };
     46 
     47 }  // namespace
     48 
     49 ChromeRenderMessageFilter::ChromeRenderMessageFilter(
     50     int render_process_id,
     51     Profile* profile)
     52     : BrowserMessageFilter(kFilteredMessageClasses,
     53                            arraysize(kFilteredMessageClasses)),
     54       render_process_id_(render_process_id),
     55       profile_(profile),
     56       predictor_(profile_->GetNetworkPredictor()),
     57       cookie_settings_(CookieSettings::Factory::GetForProfile(profile)) {
     58 }
     59 
     60 ChromeRenderMessageFilter::~ChromeRenderMessageFilter() {
     61 }
     62 
     63 bool ChromeRenderMessageFilter::OnMessageReceived(const IPC::Message& message) {
     64   bool handled = true;
     65   IPC_BEGIN_MESSAGE_MAP(ChromeRenderMessageFilter, message)
     66     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_DnsPrefetch, OnDnsPrefetch)
     67     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_Preconnect, OnPreconnect)
     68     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ResourceTypeStats,
     69                         OnResourceTypeStats)
     70     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_UpdatedCacheStats,
     71                         OnUpdatedCacheStats)
     72     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_V8HeapStats, OnV8HeapStats)
     73     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowDatabase, OnAllowDatabase)
     74     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowDOMStorage, OnAllowDOMStorage)
     75     IPC_MESSAGE_HANDLER_DELAY_REPLY(
     76         ChromeViewHostMsg_RequestFileSystemAccessSync,
     77         OnRequestFileSystemAccessSync)
     78     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_RequestFileSystemAccessAsync,
     79                         OnRequestFileSystemAccessAsync)
     80     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowIndexedDB, OnAllowIndexedDB)
     81 #if defined(ENABLE_PLUGINS)
     82     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_IsCrashReportingEnabled,
     83                         OnIsCrashReportingEnabled)
     84 #endif
     85     IPC_MESSAGE_UNHANDLED(handled = false)
     86   IPC_END_MESSAGE_MAP()
     87 
     88   return handled;
     89 }
     90 
     91 void ChromeRenderMessageFilter::OverrideThreadForMessage(
     92     const IPC::Message& message, BrowserThread::ID* thread) {
     93   switch (message.type()) {
     94     case ChromeViewHostMsg_ResourceTypeStats::ID:
     95     case ChromeViewHostMsg_UpdatedCacheStats::ID:
     96       *thread = BrowserThread::UI;
     97       break;
     98     default:
     99       break;
    100   }
    101 }
    102 
    103 void ChromeRenderMessageFilter::OnDnsPrefetch(
    104     const std::vector<std::string>& hostnames) {
    105   if (predictor_)
    106     predictor_->DnsPrefetchList(hostnames);
    107 }
    108 
    109 void ChromeRenderMessageFilter::OnPreconnect(const GURL& url) {
    110   if (predictor_)
    111     predictor_->PreconnectUrl(
    112         url, GURL(), chrome_browser_net::UrlInfo::MOUSE_OVER_MOTIVATED, 1);
    113 }
    114 
    115 void ChromeRenderMessageFilter::OnResourceTypeStats(
    116     const WebCache::ResourceTypeStats& stats) {
    117   LOCAL_HISTOGRAM_COUNTS("WebCoreCache.ImagesSizeKB",
    118                          static_cast<int>(stats.images.size / 1024));
    119   LOCAL_HISTOGRAM_COUNTS("WebCoreCache.CSSStylesheetsSizeKB",
    120                          static_cast<int>(stats.cssStyleSheets.size / 1024));
    121   LOCAL_HISTOGRAM_COUNTS("WebCoreCache.ScriptsSizeKB",
    122                          static_cast<int>(stats.scripts.size / 1024));
    123   LOCAL_HISTOGRAM_COUNTS("WebCoreCache.XSLStylesheetsSizeKB",
    124                          static_cast<int>(stats.xslStyleSheets.size / 1024));
    125   LOCAL_HISTOGRAM_COUNTS("WebCoreCache.FontsSizeKB",
    126                          static_cast<int>(stats.fonts.size / 1024));
    127 
    128   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    129 #if defined(ENABLE_TASK_MANAGER)
    130   TaskManager::GetInstance()->model()->NotifyResourceTypeStats(peer_pid(),
    131                                                                stats);
    132 #endif  // defined(ENABLE_TASK_MANAGER)
    133 }
    134 
    135 void ChromeRenderMessageFilter::OnUpdatedCacheStats(
    136     const WebCache::UsageStats& stats) {
    137   web_cache::WebCacheManager::GetInstance()->ObserveStats(
    138       render_process_id_, stats);
    139 }
    140 
    141 void ChromeRenderMessageFilter::OnV8HeapStats(int v8_memory_allocated,
    142                                               int v8_memory_used) {
    143   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
    144     BrowserThread::PostTask(
    145         BrowserThread::UI, FROM_HERE,
    146         base::Bind(&ChromeRenderMessageFilter::OnV8HeapStats, this,
    147                    v8_memory_allocated, v8_memory_used));
    148     return;
    149   }
    150 
    151   base::ProcessId renderer_id = peer_pid();
    152 
    153 #if defined(ENABLE_TASK_MANAGER)
    154   TaskManager::GetInstance()->model()->NotifyV8HeapStats(
    155       renderer_id,
    156       static_cast<size_t>(v8_memory_allocated),
    157       static_cast<size_t>(v8_memory_used));
    158 #endif  // defined(ENABLE_TASK_MANAGER)
    159 
    160   V8HeapStatsDetails details(v8_memory_allocated, v8_memory_used);
    161   content::NotificationService::current()->Notify(
    162       chrome::NOTIFICATION_RENDERER_V8_HEAP_STATS_COMPUTED,
    163       content::Source<const base::ProcessId>(&renderer_id),
    164       content::Details<const V8HeapStatsDetails>(&details));
    165 }
    166 
    167 void ChromeRenderMessageFilter::OnAllowDatabase(
    168     int render_frame_id,
    169     const GURL& origin_url,
    170     const GURL& top_origin_url,
    171     const base::string16& name,
    172     const base::string16& display_name,
    173     bool* allowed) {
    174   *allowed =
    175       cookie_settings_->IsSettingCookieAllowed(origin_url, top_origin_url);
    176   BrowserThread::PostTask(
    177       BrowserThread::UI, FROM_HERE,
    178       base::Bind(&TabSpecificContentSettings::WebDatabaseAccessed,
    179                  render_process_id_, render_frame_id, origin_url, name,
    180                  display_name, !*allowed));
    181 }
    182 
    183 void ChromeRenderMessageFilter::OnAllowDOMStorage(int render_frame_id,
    184                                                   const GURL& origin_url,
    185                                                   const GURL& top_origin_url,
    186                                                   bool local,
    187                                                   bool* allowed) {
    188   *allowed =
    189       cookie_settings_->IsSettingCookieAllowed(origin_url, top_origin_url);
    190   // Record access to DOM storage for potential display in UI.
    191   BrowserThread::PostTask(
    192       BrowserThread::UI, FROM_HERE,
    193       base::Bind(&TabSpecificContentSettings::DOMStorageAccessed,
    194                  render_process_id_, render_frame_id, origin_url, local,
    195                  !*allowed));
    196 }
    197 
    198 void ChromeRenderMessageFilter::OnRequestFileSystemAccessSync(
    199     int render_frame_id,
    200     const GURL& origin_url,
    201     const GURL& top_origin_url,
    202     IPC::Message* reply_msg) {
    203   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    204   base::Callback<void(bool)> callback =
    205       base::Bind(&ChromeRenderMessageFilter::
    206                  OnRequestFileSystemAccessSyncResponse,
    207                  make_scoped_refptr(this),
    208                  reply_msg);
    209   OnRequestFileSystemAccess(render_frame_id,
    210                             origin_url,
    211                             top_origin_url,
    212                             callback);
    213 }
    214 
    215 void ChromeRenderMessageFilter::OnRequestFileSystemAccessSyncResponse(
    216     IPC::Message* reply_msg,
    217     bool allowed) {
    218   ChromeViewHostMsg_RequestFileSystemAccessSync::WriteReplyParams(reply_msg,
    219                                                                   allowed);
    220   Send(reply_msg);
    221 }
    222 
    223 #if defined(ENABLE_EXTENSIONS)
    224 void ChromeRenderMessageFilter::FileSystemAccessedSyncOnUIThread(
    225     int render_process_id,
    226     int render_frame_id,
    227     const GURL& url,
    228     bool blocked_by_policy,
    229     IPC::Message* reply_msg) {
    230   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    231   extensions::WebViewPermissionHelper* web_view_permission_helper =
    232       extensions::WebViewPermissionHelper::FromFrameID(
    233           render_process_id, render_frame_id);
    234   // Between the time the permission request is made and the time it is handled
    235   // by the UI thread, the extensions::WebViewPermissionHelper might be gone.
    236   if (!web_view_permission_helper)
    237     return;
    238   web_view_permission_helper->FileSystemAccessedSync(
    239       render_process_id, render_frame_id, url, blocked_by_policy, reply_msg);
    240 }
    241 #endif
    242 
    243 void ChromeRenderMessageFilter::OnRequestFileSystemAccessAsync(
    244     int render_frame_id,
    245     int request_id,
    246     const GURL& origin_url,
    247     const GURL& top_origin_url) {
    248   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    249   base::Callback<void(bool)> callback =
    250       base::Bind(&ChromeRenderMessageFilter::
    251                  OnRequestFileSystemAccessAsyncResponse,
    252                  make_scoped_refptr(this),
    253                  render_frame_id,
    254                  request_id);
    255   OnRequestFileSystemAccess(render_frame_id,
    256                             origin_url,
    257                             top_origin_url,
    258                             callback);
    259 }
    260 
    261 void ChromeRenderMessageFilter::OnRequestFileSystemAccessAsyncResponse(
    262     int render_frame_id,
    263     int request_id,
    264     bool allowed) {
    265   Send(new ChromeViewMsg_RequestFileSystemAccessAsyncResponse(
    266       render_frame_id, request_id, allowed));
    267 }
    268 
    269 void ChromeRenderMessageFilter::OnRequestFileSystemAccess(
    270     int render_frame_id,
    271     const GURL& origin_url,
    272     const GURL& top_origin_url,
    273     base::Callback<void(bool)> callback) {
    274   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
    275 
    276   bool allowed =
    277       cookie_settings_->IsSettingCookieAllowed(origin_url, top_origin_url);
    278 
    279 #if defined(ENABLE_EXTENSIONS)
    280   bool is_web_view_guest = extensions::WebViewRendererState::GetInstance()
    281       ->IsGuest(render_process_id_);
    282   if (is_web_view_guest) {
    283     // Record access to file system for potential display in UI.
    284     BrowserThread::PostTask(
    285         BrowserThread::UI,
    286         FROM_HERE,
    287         base::Bind(&ChromeRenderMessageFilter::FileSystemAccessedOnUIThread,
    288                    render_process_id_,
    289                    render_frame_id,
    290                    origin_url,
    291                    allowed,
    292                    callback));
    293     return;
    294   }
    295 #endif
    296   callback.Run(allowed);
    297   // Record access to file system for potential display in UI.
    298   BrowserThread::PostTask(
    299       BrowserThread::UI,
    300       FROM_HERE,
    301       base::Bind(&TabSpecificContentSettings::FileSystemAccessed,
    302                  render_process_id_,
    303                  render_frame_id,
    304                  origin_url,
    305                  !allowed));
    306 }
    307 
    308 #if defined(ENABLE_EXTENSIONS)
    309 void ChromeRenderMessageFilter::FileSystemAccessedOnUIThread(
    310     int render_process_id,
    311     int render_frame_id,
    312     const GURL& url,
    313     bool allowed,
    314     base::Callback<void(bool)> callback) {
    315   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    316   extensions::WebViewPermissionHelper* web_view_permission_helper =
    317       extensions::WebViewPermissionHelper::FromFrameID(
    318           render_process_id, render_frame_id);
    319   // Between the time the permission request is made and the time it is handled
    320   // by the UI thread, the extensions::WebViewPermissionHelper might be gone.
    321   if (!web_view_permission_helper)
    322     return;
    323   web_view_permission_helper->RequestFileSystemPermission(
    324       url,
    325       allowed,
    326       base::Bind(&ChromeRenderMessageFilter::FileSystemAccessedResponse,
    327                  render_process_id,
    328                  render_frame_id,
    329                  url,
    330                  callback));
    331 }
    332 
    333 void ChromeRenderMessageFilter::FileSystemAccessedResponse(
    334     int render_process_id,
    335     int render_frame_id,
    336     const GURL& url,
    337     base::Callback<void(bool)> callback,
    338     bool allowed) {
    339   TabSpecificContentSettings::FileSystemAccessed(
    340       render_process_id, render_frame_id, url, !allowed);
    341   callback.Run(allowed);
    342 }
    343 #endif
    344 
    345 void ChromeRenderMessageFilter::OnAllowIndexedDB(int render_frame_id,
    346                                                  const GURL& origin_url,
    347                                                  const GURL& top_origin_url,
    348                                                  const base::string16& name,
    349                                                  bool* allowed) {
    350   *allowed =
    351       cookie_settings_->IsSettingCookieAllowed(origin_url, top_origin_url);
    352   BrowserThread::PostTask(
    353       BrowserThread::UI, FROM_HERE,
    354       base::Bind(&TabSpecificContentSettings::IndexedDBAccessed,
    355                  render_process_id_, render_frame_id, origin_url, name,
    356                  !*allowed));
    357 }
    358 
    359 #if defined(ENABLE_PLUGINS)
    360 void ChromeRenderMessageFilter::OnIsCrashReportingEnabled(bool* enabled) {
    361   *enabled = ChromeMetricsServiceAccessor::IsCrashReportingEnabled();
    362 }
    363 #endif
    364