#include "base/bind.h"
#include "base/bind_helpers.h"
-#include "base/command_line.h"
-#include "base/metrics/field_trial.h"
#include "base/metrics/histogram.h"
-#include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/automation/automation_resource_message_filter.h"
-#include "chrome/browser/browser_process.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/content_settings/cookie_settings.h"
#include "chrome/browser/content_settings/tab_specific_content_settings.h"
-#include "chrome/browser/extensions/activity_log/activity_action_constants.h"
-#include "chrome/browser/extensions/activity_log/activity_actions.h"
-#include "chrome/browser/extensions/activity_log/activity_log.h"
-#include "chrome/browser/extensions/api/activity_log_private/activity_log_private_api.h"
-#include "chrome/browser/extensions/api/messaging/message_service.h"
-#include "chrome/browser/extensions/event_router.h"
-#include "chrome/browser/extensions/extension_process_manager.h"
-#include "chrome/browser/extensions/extension_system.h"
-#include "chrome/browser/google/google_util.h"
-#include "chrome/browser/net/chrome_url_request_context.h"
+#include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
#include "chrome/browser/net/predictor.h"
+#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/browser/task_manager/task_manager.h"
-#include "chrome/common/chrome_switches.h"
+#include "chrome/browser/renderer_host/web_cache_manager.h"
#include "chrome/common/extensions/api/i18n/default_locale_handler.h"
-#include "chrome/common/extensions/extension_file_util.h"
-#include "chrome/common/extensions/extension_messages.h"
-#include "chrome/common/extensions/message_bundle.h"
#include "chrome/common/render_messages.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/render_process_host.h"
-#include "content/public/browser/resource_dispatcher_host.h"
-#include "extensions/common/constants.h"
+
+#if defined(ENABLE_EXTENSIONS)
+#include "chrome/browser/guest_view/web_view/web_view_permission_helper.h"
+#include "chrome/browser/guest_view/web_view/web_view_renderer_state.h"
+#endif
+
+#if defined(ENABLE_TASK_MANAGER)
+#include "chrome/browser/task_manager/task_manager.h"
+#endif
#if defined(USE_TCMALLOC)
#include "chrome/browser/browser_about_handler.h"
#endif
using content::BrowserThread;
-using extensions::APIPermission;
-using WebKit::WebCache;
+using blink::WebCache;
namespace {
-// Logs an action to the extension activity log for the specified profile. Can
-// be called from any thread.
-void AddActionToExtensionActivityLog(
- Profile* profile,
- scoped_refptr<extensions::Action> action) {
-#if defined(ENABLE_EXTENSIONS)
- // The ActivityLog can only be accessed from the main (UI) thread. If we're
- // running on the wrong thread, re-dispatch from the main thread.
- if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
- BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
- base::Bind(&AddActionToExtensionActivityLog, profile, action));
- } else {
- if (!g_browser_process->profile_manager()->IsValidProfile(profile))
- return;
- // If the action included a URL, check whether it is for an incognito
- // profile. The check is performed here so that it can safely be done from
- // the UI thread.
- if (action->page_url().is_valid() || !action->page_title().empty())
- action->set_page_incognito(profile->IsOffTheRecord());
- extensions::ActivityLog* activity_log =
- extensions::ActivityLog::GetInstance(profile);
- activity_log->LogAction(action);
- }
-#endif
-}
+const uint32 kFilteredMessageClasses[] = {
+ ChromeMsgStart,
+};
-} // namespace
+} // namespace
ChromeRenderMessageFilter::ChromeRenderMessageFilter(
int render_process_id,
- Profile* profile,
- net::URLRequestContextGetter* request_context)
- : render_process_id_(render_process_id),
+ Profile* profile)
+ : BrowserMessageFilter(kFilteredMessageClasses,
+ arraysize(kFilteredMessageClasses)),
+ render_process_id_(render_process_id),
profile_(profile),
- off_the_record_(profile_->IsOffTheRecord()),
- request_context_(request_context),
- extension_info_map_(
- extensions::ExtensionSystem::Get(profile)->info_map()),
- cookie_settings_(CookieSettings::Factory::GetForProfile(profile)),
- weak_ptr_factory_(this) {
+ predictor_(profile_->GetNetworkPredictor()),
+ cookie_settings_(CookieSettings::Factory::GetForProfile(profile)) {
}
ChromeRenderMessageFilter::~ChromeRenderMessageFilter() {
}
-bool ChromeRenderMessageFilter::OnMessageReceived(const IPC::Message& message,
- bool* message_was_ok) {
+bool ChromeRenderMessageFilter::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
- IPC_BEGIN_MESSAGE_MAP_EX(ChromeRenderMessageFilter, message, *message_was_ok)
+ IPC_BEGIN_MESSAGE_MAP(ChromeRenderMessageFilter, message)
IPC_MESSAGE_HANDLER(ChromeViewHostMsg_DnsPrefetch, OnDnsPrefetch)
IPC_MESSAGE_HANDLER(ChromeViewHostMsg_Preconnect, OnPreconnect)
IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ResourceTypeStats,
OnResourceTypeStats)
IPC_MESSAGE_HANDLER(ChromeViewHostMsg_UpdatedCacheStats,
OnUpdatedCacheStats)
- IPC_MESSAGE_HANDLER(ChromeViewHostMsg_FPS, OnFPS)
IPC_MESSAGE_HANDLER(ChromeViewHostMsg_V8HeapStats, OnV8HeapStats)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToExtension,
- OnOpenChannelToExtension)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToTab, OnOpenChannelToTab)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_OpenChannelToNativeApp,
- OnOpenChannelToNativeApp)
- IPC_MESSAGE_HANDLER_DELAY_REPLY(ExtensionHostMsg_GetMessageBundle,
- OnGetExtensionMessageBundle)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddListener, OnExtensionAddListener)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveListener,
- OnExtensionRemoveListener)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddLazyListener,
- OnExtensionAddLazyListener)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveLazyListener,
- OnExtensionRemoveLazyListener)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddFilteredListener,
- OnExtensionAddFilteredListener)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_RemoveFilteredListener,
- OnExtensionRemoveFilteredListener)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_CloseChannel, OnExtensionCloseChannel)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_RequestForIOThread,
- OnExtensionRequestForIOThread)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_ShouldSuspendAck,
- OnExtensionShouldSuspendAck)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_GenerateUniqueID,
- OnExtensionGenerateUniqueID)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_SuspendAck, OnExtensionSuspendAck)
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_ResumeRequests,
- OnExtensionResumeRequests);
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddAPIActionToActivityLog,
- OnAddAPIActionToExtensionActivityLog);
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddDOMActionToActivityLog,
- OnAddDOMActionToExtensionActivityLog);
- IPC_MESSAGE_HANDLER(ExtensionHostMsg_AddEventToActivityLog,
- OnAddEventToExtensionActivityLog);
IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowDatabase, OnAllowDatabase)
IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowDOMStorage, OnAllowDOMStorage)
- IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowFileSystem, OnAllowFileSystem)
+ IPC_MESSAGE_HANDLER_DELAY_REPLY(
+ ChromeViewHostMsg_RequestFileSystemAccessSync,
+ OnRequestFileSystemAccessSync)
+ IPC_MESSAGE_HANDLER(ChromeViewHostMsg_RequestFileSystemAccessAsync,
+ OnRequestFileSystemAccessAsync)
IPC_MESSAGE_HANDLER(ChromeViewHostMsg_AllowIndexedDB, OnAllowIndexedDB)
- IPC_MESSAGE_HANDLER(ChromeViewHostMsg_CanTriggerClipboardRead,
- OnCanTriggerClipboardRead)
- IPC_MESSAGE_HANDLER(ChromeViewHostMsg_CanTriggerClipboardWrite,
- OnCanTriggerClipboardWrite)
- IPC_MESSAGE_HANDLER(ChromeViewHostMsg_IsWebGLDebugRendererInfoAllowed,
- OnIsWebGLDebugRendererInfoAllowed)
+#if defined(ENABLE_PLUGINS)
+ IPC_MESSAGE_HANDLER(ChromeViewHostMsg_IsCrashReportingEnabled,
+ OnIsCrashReportingEnabled)
+#endif
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
-#if defined(ENABLE_AUTOMATION)
- if ((message.type() == ChromeViewHostMsg_GetCookies::ID ||
- message.type() == ChromeViewHostMsg_SetCookie::ID) &&
- AutomationResourceMessageFilter::ShouldFilterCookieMessages(
- render_process_id_, message.routing_id())) {
- // ChromeFrame then we need to get/set cookies from the external host.
- IPC_BEGIN_MESSAGE_MAP_EX(ChromeRenderMessageFilter, message,
- *message_was_ok)
- IPC_MESSAGE_HANDLER_DELAY_REPLY(ChromeViewHostMsg_GetCookies,
- OnGetCookies)
- IPC_MESSAGE_HANDLER(ChromeViewHostMsg_SetCookie, OnSetCookie)
- IPC_END_MESSAGE_MAP()
- handled = true;
- }
-#endif
-
return handled;
}
const IPC::Message& message, BrowserThread::ID* thread) {
switch (message.type()) {
case ChromeViewHostMsg_ResourceTypeStats::ID:
- case ExtensionHostMsg_AddListener::ID:
- case ExtensionHostMsg_RemoveListener::ID:
- case ExtensionHostMsg_AddLazyListener::ID:
- case ExtensionHostMsg_RemoveLazyListener::ID:
- case ExtensionHostMsg_AddFilteredListener::ID:
- case ExtensionHostMsg_RemoveFilteredListener::ID:
- case ExtensionHostMsg_CloseChannel::ID:
- case ExtensionHostMsg_ShouldSuspendAck::ID:
- case ExtensionHostMsg_SuspendAck::ID:
case ChromeViewHostMsg_UpdatedCacheStats::ID:
*thread = BrowserThread::UI;
break;
}
}
-net::HostResolver* ChromeRenderMessageFilter::GetHostResolver() {
- return request_context_->GetURLRequestContext()->host_resolver();
-}
-
void ChromeRenderMessageFilter::OnDnsPrefetch(
const std::vector<std::string>& hostnames) {
- if (profile_->GetNetworkPredictor())
- profile_->GetNetworkPredictor()->DnsPrefetchList(hostnames);
+ if (predictor_)
+ predictor_->DnsPrefetchList(hostnames);
}
void ChromeRenderMessageFilter::OnPreconnect(const GURL& url) {
- if (profile_->GetNetworkPredictor())
- profile_->GetNetworkPredictor()->PreconnectUrl(
+ if (predictor_)
+ predictor_->PreconnectUrl(
url, GURL(), chrome_browser_net::UrlInfo::MOUSE_OVER_MOTIVATED, 1);
}
WebCacheManager::GetInstance()->ObserveStats(render_process_id_, stats);
}
-void ChromeRenderMessageFilter::OnFPS(int routing_id, float fps) {
- if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
- BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
- base::Bind(
- &ChromeRenderMessageFilter::OnFPS, this,
- routing_id, fps));
- return;
- }
-
- base::ProcessId renderer_id = peer_pid();
-
-#if defined(ENABLE_TASK_MANAGER)
- TaskManager::GetInstance()->model()->NotifyFPS(
- renderer_id, routing_id, fps);
-#endif // defined(ENABLE_TASK_MANAGER)
-
- FPSDetails details(routing_id, fps);
- content::NotificationService::current()->Notify(
- chrome::NOTIFICATION_RENDERER_FPS_COMPUTED,
- content::Source<const base::ProcessId>(&renderer_id),
- content::Details<const FPSDetails>(&details));
-}
-
void ChromeRenderMessageFilter::OnV8HeapStats(int v8_memory_allocated,
int v8_memory_used) {
if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
content::Details<const V8HeapStatsDetails>(&details));
}
-void ChromeRenderMessageFilter::OnOpenChannelToExtension(
- int routing_id,
- const ExtensionMsg_ExternalConnectionInfo& info,
- const std::string& channel_name,
- bool include_tls_channel_id,
- int* port_id) {
- int port2_id;
- extensions::MessageService::AllocatePortIdPair(port_id, &port2_id);
-
- BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
- base::Bind(&ChromeRenderMessageFilter::OpenChannelToExtensionOnUIThread,
- this, render_process_id_, routing_id, port2_id, info,
- channel_name, include_tls_channel_id));
-}
-
-void ChromeRenderMessageFilter::OpenChannelToExtensionOnUIThread(
- int source_process_id, int source_routing_id,
- int receiver_port_id,
- const ExtensionMsg_ExternalConnectionInfo& info,
- const std::string& channel_name,
- bool include_tls_channel_id) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- extensions::MessageService::Get(profile_)->OpenChannelToExtension(
- source_process_id, source_routing_id, receiver_port_id,
- info.source_id, info.target_id, info.source_url, channel_name,
- include_tls_channel_id);
-}
-
-void ChromeRenderMessageFilter::OnOpenChannelToNativeApp(
- int routing_id,
- const std::string& source_extension_id,
- const std::string& native_app_name,
- int* port_id) {
- int port2_id;
- extensions::MessageService::AllocatePortIdPair(port_id, &port2_id);
-
- BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
- base::Bind(&ChromeRenderMessageFilter::OpenChannelToNativeAppOnUIThread,
- this, routing_id, port2_id, source_extension_id,
- native_app_name));
-}
-
-void ChromeRenderMessageFilter::OpenChannelToNativeAppOnUIThread(
- int source_routing_id,
- int receiver_port_id,
- const std::string& source_extension_id,
- const std::string& native_app_name) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- extensions::MessageService::Get(profile_)->OpenChannelToNativeApp(
- render_process_id_, source_routing_id, receiver_port_id,
- source_extension_id, native_app_name);
-}
-
-void ChromeRenderMessageFilter::OnOpenChannelToTab(
- int routing_id, int tab_id, const std::string& extension_id,
- const std::string& channel_name, int* port_id) {
- int port2_id;
- extensions::MessageService::AllocatePortIdPair(port_id, &port2_id);
-
- BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
- base::Bind(&ChromeRenderMessageFilter::OpenChannelToTabOnUIThread, this,
- render_process_id_, routing_id, port2_id, tab_id, extension_id,
- channel_name));
-}
-
-void ChromeRenderMessageFilter::OpenChannelToTabOnUIThread(
- int source_process_id, int source_routing_id,
- int receiver_port_id,
- int tab_id,
- const std::string& extension_id,
- const std::string& channel_name) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- extensions::MessageService::Get(profile_)->OpenChannelToTab(
- source_process_id, source_routing_id, receiver_port_id,
- tab_id, extension_id, channel_name);
-}
-
-void ChromeRenderMessageFilter::OnGetExtensionMessageBundle(
- const std::string& extension_id, IPC::Message* reply_msg) {
- const extensions::Extension* extension =
- extension_info_map_->extensions().GetByID(extension_id);
- base::FilePath extension_path;
- std::string default_locale;
- if (extension) {
- extension_path = extension->path();
- default_locale = extensions::LocaleInfo::GetDefaultLocale(extension);
- }
-
- BrowserThread::PostTask(
- BrowserThread::FILE, FROM_HERE,
- base::Bind(
- &ChromeRenderMessageFilter::OnGetExtensionMessageBundleOnFileThread,
- this, extension_path, extension_id, default_locale, reply_msg));
-}
-
-void ChromeRenderMessageFilter::OnGetExtensionMessageBundleOnFileThread(
- const base::FilePath& extension_path,
- const std::string& extension_id,
- const std::string& default_locale,
- IPC::Message* reply_msg) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
- scoped_ptr<extensions::MessageBundle::SubstitutionMap> dictionary_map(
- extension_file_util::LoadMessageBundleSubstitutionMap(
- extension_path, extension_id, default_locale));
-
- ExtensionHostMsg_GetMessageBundle::WriteReplyParams(reply_msg,
- *dictionary_map);
- Send(reply_msg);
-}
-
-void ChromeRenderMessageFilter::OnExtensionAddListener(
- const std::string& extension_id,
- const std::string& event_name) {
- content::RenderProcessHost* process =
- content::RenderProcessHost::FromID(render_process_id_);
- if (!process || !extensions::ExtensionSystem::Get(profile_)->event_router())
- return;
-
- extensions::ExtensionSystem::Get(profile_)->event_router()->AddEventListener(
- event_name, process, extension_id);
-}
-
-void ChromeRenderMessageFilter::OnExtensionRemoveListener(
- const std::string& extension_id,
- const std::string& event_name) {
- content::RenderProcessHost* process =
- content::RenderProcessHost::FromID(render_process_id_);
- if (!process || !extensions::ExtensionSystem::Get(profile_)->event_router())
- return;
-
- extensions::ExtensionSystem::Get(profile_)->event_router()->
- RemoveEventListener(event_name, process, extension_id);
-}
-
-void ChromeRenderMessageFilter::OnExtensionAddLazyListener(
- const std::string& extension_id, const std::string& event_name) {
- if (extensions::ExtensionSystem::Get(profile_)->event_router()) {
- extensions::ExtensionSystem::Get(profile_)->event_router()->
- AddLazyEventListener(event_name, extension_id);
- }
-}
-
-void ChromeRenderMessageFilter::OnExtensionRemoveLazyListener(
- const std::string& extension_id, const std::string& event_name) {
- if (extensions::ExtensionSystem::Get(profile_)->event_router()) {
- extensions::ExtensionSystem::Get(profile_)->event_router()->
- RemoveLazyEventListener(event_name, extension_id);
- }
-}
-
-void ChromeRenderMessageFilter::OnExtensionAddFilteredListener(
- const std::string& extension_id,
- const std::string& event_name,
- const base::DictionaryValue& filter,
- bool lazy) {
- content::RenderProcessHost* process =
- content::RenderProcessHost::FromID(render_process_id_);
- if (!process || !extensions::ExtensionSystem::Get(profile_)->event_router())
- return;
-
- extensions::ExtensionSystem::Get(profile_)->event_router()->
- AddFilteredEventListener(event_name, process, extension_id, filter, lazy);
-}
-
-void ChromeRenderMessageFilter::OnExtensionRemoveFilteredListener(
- const std::string& extension_id,
- const std::string& event_name,
- const base::DictionaryValue& filter,
- bool lazy) {
- content::RenderProcessHost* process =
- content::RenderProcessHost::FromID(render_process_id_);
- if (!process || !extensions::ExtensionSystem::Get(profile_)->event_router())
- return;
-
- extensions::ExtensionSystem::Get(profile_)->event_router()->
- RemoveFilteredEventListener(event_name, process, extension_id, filter,
- lazy);
-}
-
-void ChromeRenderMessageFilter::OnExtensionCloseChannel(
- int port_id,
- const std::string& error_message) {
- if (!content::RenderProcessHost::FromID(render_process_id_))
- return; // To guard against crash in browser_tests shutdown.
-
- extensions::MessageService* message_service =
- extensions::MessageService::Get(profile_);
- if (message_service)
- message_service->CloseChannel(port_id, error_message);
-}
-
-void ChromeRenderMessageFilter::OnExtensionRequestForIOThread(
- int routing_id,
- const ExtensionHostMsg_Request_Params& params) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
- ExtensionFunctionDispatcher::DispatchOnIOThread(
- extension_info_map_.get(), profile_, render_process_id_,
- weak_ptr_factory_.GetWeakPtr(), routing_id, params);
-}
-
-void ChromeRenderMessageFilter::OnExtensionShouldSuspendAck(
- const std::string& extension_id, int sequence_id) {
- if (extensions::ExtensionSystem::Get(profile_)->process_manager()) {
- extensions::ExtensionSystem::Get(profile_)->process_manager()->
- OnShouldSuspendAck(extension_id, sequence_id);
- }
-}
-
-void ChromeRenderMessageFilter::OnExtensionSuspendAck(
- const std::string& extension_id) {
- if (extensions::ExtensionSystem::Get(profile_)->process_manager()) {
- extensions::ExtensionSystem::Get(profile_)->process_manager()->
- OnSuspendAck(extension_id);
- }
-}
-
-void ChromeRenderMessageFilter::OnExtensionGenerateUniqueID(int* unique_id) {
- static int next_unique_id = 0;
- *unique_id = ++next_unique_id;
-}
-
-void ChromeRenderMessageFilter::OnExtensionResumeRequests(int route_id) {
- content::ResourceDispatcherHost::Get()->ResumeBlockedRequestsForRoute(
- render_process_id_, route_id);
-}
-
-void ChromeRenderMessageFilter::OnAddAPIActionToExtensionActivityLog(
- const std::string& extension_id,
- const ExtensionHostMsg_APIActionOrEvent_Params& params) {
- scoped_refptr<extensions::Action> action = new extensions::Action(
- extension_id, base::Time::Now(), extensions::Action::ACTION_API_CALL,
- params.api_call);
- action->set_args(make_scoped_ptr(params.arguments.DeepCopy()));
- if (!params.extra.empty()) {
- action->mutable_other()->SetString(
- activity_log_constants::kActionExtra, params.extra);
- }
- AddActionToExtensionActivityLog(profile_, action);
-}
-
-void ChromeRenderMessageFilter::OnAddDOMActionToExtensionActivityLog(
- const std::string& extension_id,
- const ExtensionHostMsg_DOMAction_Params& params) {
- scoped_refptr<extensions::Action> action = new extensions::Action(
- extension_id, base::Time::Now(), extensions::Action::ACTION_DOM_ACCESS,
- params.api_call);
- action->set_args(make_scoped_ptr(params.arguments.DeepCopy()));
- action->set_page_url(params.url);
- action->set_page_title(base::UTF16ToUTF8(params.url_title));
- action->mutable_other()->SetInteger(activity_log_constants::kActionDomVerb,
- params.call_type);
- AddActionToExtensionActivityLog(profile_, action);
-}
-
-void ChromeRenderMessageFilter::OnAddEventToExtensionActivityLog(
- const std::string& extension_id,
- const ExtensionHostMsg_APIActionOrEvent_Params& params) {
- scoped_refptr<extensions::Action> action = new extensions::Action(
- extension_id, base::Time::Now(), extensions::Action::ACTION_API_EVENT,
- params.api_call);
- action->set_args(make_scoped_ptr(params.arguments.DeepCopy()));
- if (!params.extra.empty()) {
- action->mutable_other()->SetString(activity_log_constants::kActionExtra,
- params.extra);
- }
- AddActionToExtensionActivityLog(profile_, action);
-}
-
-void ChromeRenderMessageFilter::OnAllowDatabase(int render_view_id,
- const GURL& origin_url,
- const GURL& top_origin_url,
- const string16& name,
- const string16& display_name,
- bool* allowed) {
+void ChromeRenderMessageFilter::OnAllowDatabase(
+ int render_frame_id,
+ const GURL& origin_url,
+ const GURL& top_origin_url,
+ const base::string16& name,
+ const base::string16& display_name,
+ bool* allowed) {
*allowed =
cookie_settings_->IsSettingCookieAllowed(origin_url, top_origin_url);
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&TabSpecificContentSettings::WebDatabaseAccessed,
- render_process_id_, render_view_id, origin_url, name,
+ render_process_id_, render_frame_id, origin_url, name,
display_name, !*allowed));
}
-void ChromeRenderMessageFilter::OnAllowDOMStorage(int render_view_id,
+void ChromeRenderMessageFilter::OnAllowDOMStorage(int render_frame_id,
const GURL& origin_url,
const GURL& top_origin_url,
bool local,
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&TabSpecificContentSettings::DOMStorageAccessed,
- render_process_id_, render_view_id, origin_url, local,
+ render_process_id_, render_frame_id, origin_url, local,
!*allowed));
}
-void ChromeRenderMessageFilter::OnAllowFileSystem(int render_view_id,
- const GURL& origin_url,
- const GURL& top_origin_url,
- bool* allowed) {
- *allowed =
+void ChromeRenderMessageFilter::OnRequestFileSystemAccessSync(
+ int render_frame_id,
+ const GURL& origin_url,
+ const GURL& top_origin_url,
+ IPC::Message* reply_msg) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ base::Callback<void(bool)> callback =
+ base::Bind(&ChromeRenderMessageFilter::
+ OnRequestFileSystemAccessSyncResponse,
+ make_scoped_refptr(this),
+ reply_msg);
+ OnRequestFileSystemAccess(render_frame_id,
+ origin_url,
+ top_origin_url,
+ callback);
+}
+
+void ChromeRenderMessageFilter::OnRequestFileSystemAccessSyncResponse(
+ IPC::Message* reply_msg,
+ bool allowed) {
+ ChromeViewHostMsg_RequestFileSystemAccessSync::WriteReplyParams(reply_msg,
+ allowed);
+ Send(reply_msg);
+}
+
+#if defined(ENABLE_EXTENSIONS)
+void ChromeRenderMessageFilter::FileSystemAccessedSyncOnUIThread(
+ int render_process_id,
+ int render_frame_id,
+ const GURL& url,
+ bool blocked_by_policy,
+ IPC::Message* reply_msg) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ extensions::WebViewPermissionHelper* web_view_permission_helper =
+ extensions::WebViewPermissionHelper::FromFrameID(
+ render_process_id, render_frame_id);
+ // Between the time the permission request is made and the time it is handled
+ // by the UI thread, the extensions::WebViewPermissionHelper might be gone.
+ if (!web_view_permission_helper)
+ return;
+ web_view_permission_helper->FileSystemAccessedSync(
+ render_process_id, render_frame_id, url, blocked_by_policy, reply_msg);
+}
+#endif
+
+void ChromeRenderMessageFilter::OnRequestFileSystemAccessAsync(
+ int render_frame_id,
+ int request_id,
+ const GURL& origin_url,
+ const GURL& top_origin_url) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ base::Callback<void(bool)> callback =
+ base::Bind(&ChromeRenderMessageFilter::
+ OnRequestFileSystemAccessAsyncResponse,
+ make_scoped_refptr(this),
+ render_frame_id,
+ request_id);
+ OnRequestFileSystemAccess(render_frame_id,
+ origin_url,
+ top_origin_url,
+ callback);
+}
+
+void ChromeRenderMessageFilter::OnRequestFileSystemAccessAsyncResponse(
+ int render_frame_id,
+ int request_id,
+ bool allowed) {
+ Send(new ChromeViewMsg_RequestFileSystemAccessAsyncResponse(
+ render_frame_id, request_id, allowed));
+}
+
+void ChromeRenderMessageFilter::OnRequestFileSystemAccess(
+ int render_frame_id,
+ const GURL& origin_url,
+ const GURL& top_origin_url,
+ base::Callback<void(bool)> callback) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+ bool allowed =
cookie_settings_->IsSettingCookieAllowed(origin_url, top_origin_url);
+
+#if defined(ENABLE_EXTENSIONS)
+ bool is_web_view_guest = extensions::WebViewRendererState::GetInstance()
+ ->IsGuest(render_process_id_);
+ if (is_web_view_guest) {
+ // Record access to file system for potential display in UI.
+ BrowserThread::PostTask(
+ BrowserThread::UI,
+ FROM_HERE,
+ base::Bind(&ChromeRenderMessageFilter::FileSystemAccessedOnUIThread,
+ render_process_id_,
+ render_frame_id,
+ origin_url,
+ allowed,
+ callback));
+ return;
+ }
+#endif
+ callback.Run(allowed);
// Record access to file system for potential display in UI.
BrowserThread::PostTask(
- BrowserThread::UI, FROM_HERE,
+ BrowserThread::UI,
+ FROM_HERE,
base::Bind(&TabSpecificContentSettings::FileSystemAccessed,
- render_process_id_, render_view_id, origin_url, !*allowed));
+ render_process_id_,
+ render_frame_id,
+ origin_url,
+ !allowed));
+}
+
+#if defined(ENABLE_EXTENSIONS)
+void ChromeRenderMessageFilter::FileSystemAccessedOnUIThread(
+ int render_process_id,
+ int render_frame_id,
+ const GURL& url,
+ bool allowed,
+ base::Callback<void(bool)> callback) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+ extensions::WebViewPermissionHelper* web_view_permission_helper =
+ extensions::WebViewPermissionHelper::FromFrameID(
+ render_process_id, render_frame_id);
+ // Between the time the permission request is made and the time it is handled
+ // by the UI thread, the extensions::WebViewPermissionHelper might be gone.
+ if (!web_view_permission_helper)
+ return;
+ web_view_permission_helper->RequestFileSystemPermission(
+ url,
+ allowed,
+ base::Bind(&ChromeRenderMessageFilter::FileSystemAccessedResponse,
+ render_process_id,
+ render_frame_id,
+ url,
+ callback));
}
-void ChromeRenderMessageFilter::OnAllowIndexedDB(int render_view_id,
+void ChromeRenderMessageFilter::FileSystemAccessedResponse(
+ int render_process_id,
+ int render_frame_id,
+ const GURL& url,
+ base::Callback<void(bool)> callback,
+ bool allowed) {
+ TabSpecificContentSettings::FileSystemAccessed(
+ render_process_id, render_frame_id, url, !allowed);
+ callback.Run(allowed);
+}
+#endif
+
+void ChromeRenderMessageFilter::OnAllowIndexedDB(int render_frame_id,
const GURL& origin_url,
const GURL& top_origin_url,
- const string16& name,
+ const base::string16& name,
bool* allowed) {
*allowed =
cookie_settings_->IsSettingCookieAllowed(origin_url, top_origin_url);
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&TabSpecificContentSettings::IndexedDBAccessed,
- render_process_id_, render_view_id, origin_url, name,
+ render_process_id_, render_frame_id, origin_url, name,
!*allowed));
}
-void ChromeRenderMessageFilter::OnCanTriggerClipboardRead(
- const GURL& origin, bool* allowed) {
- *allowed = extension_info_map_->SecurityOriginHasAPIPermission(
- origin, render_process_id_, APIPermission::kClipboardRead);
+#if defined(ENABLE_PLUGINS)
+void ChromeRenderMessageFilter::OnIsCrashReportingEnabled(bool* enabled) {
+ *enabled = ChromeMetricsServiceAccessor::IsCrashReportingEnabled();
}
-
-void ChromeRenderMessageFilter::OnCanTriggerClipboardWrite(
- const GURL& origin, bool* allowed) {
- // Since all extensions could historically write to the clipboard, preserve it
- // for compatibility.
- *allowed = (origin.SchemeIs(extensions::kExtensionScheme) ||
- extension_info_map_->SecurityOriginHasAPIPermission(
- origin, render_process_id_, APIPermission::kClipboardWrite));
-}
-
-void ChromeRenderMessageFilter::OnIsWebGLDebugRendererInfoAllowed(
- const GURL& origin, bool* allowed) {
- *allowed = false;
- const CommandLine& command_line = *CommandLine::ForCurrentProcess();
- if (command_line.HasSwitch(switches::kDisableWebGLDebugRendererInfo))
- return;
-
- // TODO(zmo): in this experimental stage, we only expose WebGL extension
- // WEBGL_debug_renderer_info for Google domains. Once we finish the experiment
- // and make a decision, this extension should be avaiable to all or none.
- if (!google_util::IsGoogleDomainUrl(origin, google_util::ALLOW_SUBDOMAIN,
- google_util::ALLOW_NON_STANDARD_PORTS)) {
- return;
- }
-
- const char kWebGLDebugRendererInfoFieldTrialName[] = "WebGLDebugRendererInfo";
- const char kWebGLDebugRendererInfoFieldTrialEnabledName[] = "enabled";
- *allowed = (base::FieldTrialList::FindFullName(
- kWebGLDebugRendererInfoFieldTrialName) ==
- kWebGLDebugRendererInfoFieldTrialEnabledName);
-}
-
-void ChromeRenderMessageFilter::OnGetCookies(
- const GURL& url,
- const GURL& first_party_for_cookies,
- IPC::Message* reply_msg) {
-#if defined(ENABLE_AUTOMATION)
- AutomationResourceMessageFilter::GetCookiesForUrl(
- this, request_context_->GetURLRequestContext(), render_process_id_,
- reply_msg, url);
#endif
-}
-
-void ChromeRenderMessageFilter::OnSetCookie(const IPC::Message& message,
- const GURL& url,
- const GURL& first_party_for_cookies,
- const std::string& cookie) {
-#if defined(ENABLE_AUTOMATION)
- AutomationResourceMessageFilter::SetCookiesForUrl(
- render_process_id_, message.routing_id(), url, cookie);
-#endif
-}
projects / platform / framework / web / crosswalk.git / blobdiff