# SVN revision while Blink is still in SVN.
blink_upstream_rev = '191638' #TODO(TK) : need to update revision number
-efl_integration_branch = 'origin/dev/m50_2661'
+efl_integration_branch = 'origin/dev/m51_2704'
ct_git = 'ssh://165.213.202.130:29418/webplatform'
crosswalk_git = 'https://github.com/crosswalk-project'
void JavaScriptDialogManagerEfl::RunJavaScriptDialog(
content::WebContents* web_contents,
const GURL& origin_url,
- const std::string& accept_lang,
content::JavaScriptMessageType type,
const base::string16& message_text,
const base::string16& default_prompt_text,
void JavaScriptDialogManagerEfl::RunBeforeUnloadDialog(
content::WebContents* web_contents,
- const base::string16& message_text,
bool is_reload,
const DialogClosedCallback& callback) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
CancelActiveAndPendingDialogs(web_contents);
- open_dialogs_[web_contents] = new JavaScriptModalDialogEfl(web_contents,
- JavaScriptModalDialogEfl::NAVIGATION,
+ open_dialogs_[web_contents] = new JavaScriptModalDialogEfl(
+ web_contents, JavaScriptModalDialogEfl::NAVIGATION,
base::UTF8ToUTF16(
std::string(dgettext("WebKit", "IDS_WEBVIEW_BEFOREUNLOAD_MESSAGE"))),
- message_text, callback);
+ base::string16(), callback);
}
bool JavaScriptDialogManagerEfl::HandleJavaScriptDialog(
void RunJavaScriptDialog(
content::WebContents* web_contents,
const GURL& origin_url,
- const std::string& accept_lang,
content::JavaScriptMessageType type,
const base::string16& message_text,
const base::string16& default_prompt_text,
bool* did_suppress_message) override;
void RunBeforeUnloadDialog(
content::WebContents* web_contents,
- const base::string16& message_text,
bool is_reload,
const DialogClosedCallback& callback) override;
bool HandleJavaScriptDialog(
#include "cc/raster/single_thread_task_graph_runner.h"
#include "cc/surfaces/onscreen_display_client.h"
#include "cc/surfaces/surface_display_output_surface.h"
+#include "content/browser/compositor/gl_helper.h"
#include "content/browser/compositor/mailbox_output_surface_efl.h"
#include "content/browser/gpu/browser_gpu_channel_host_factory.h"
#include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
-#include "content/common/gpu/client/gl_helper.h"
+#include "content/browser/gpu/gpu_surface_tracker.h"
#include "content/common/host_shared_bitmap_manager.h"
#include "ui/compositor/reflector.h"
static scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
CreateGpuProcessViewContext(
- const scoped_refptr<GpuChannelHost>& gpu_channel_host,
- const blink::WebGraphicsContext3D::Attributes attributes,
+ const scoped_refptr<gpu::GpuChannelHost>& gpu_channel_host,
+ const gpu::gles2::ContextCreationAttribHelper attributes,
int surface_id) {
DCHECK(gpu_channel_host.get());
+ GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
+ gpu::SurfaceHandle surface_handle =
+ surface_id ? tracker->GetSurfaceHandle(surface_id)
+ : gpu::kNullSurfaceHandle;
GURL url("chrome://gpu/Compositor::createContext3D");
- bool lose_context_when_out_of_memory = true;
+ bool share_resources = true;
+ bool automatic_flushes = false;
return make_scoped_ptr(new WebGraphicsContext3DCommandBufferImpl(
- surface_id, url, gpu_channel_host.get(), attributes,
- lose_context_when_out_of_memory,
+ surface_handle, url, gpu_channel_host.get(), attributes,
+ gfx::PreferIntegratedGpu, share_resources, automatic_flushes,
WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(), NULL));
}
void ContextFactoryEfl::CreateOutputSurface(
base::WeakPtr<ui::Compositor> compositor) {
- blink::WebGraphicsContext3D::Attributes attrs;
- attrs.depth = false;
- attrs.stencil = false;
- attrs.antialias = false;
- attrs.shareResources = true;
- attrs.noAutomaticFlushes = true;
+ gpu::gles2::ContextCreationAttribHelper attrs;
+ attrs.alpha_size = -1;
+ attrs.depth_size = 0;
+ attrs.stencil_size = 0;
+ attrs.samples = 0;
+ attrs.sample_buffers = 0;
+ attrs.bind_generates_resource = false;
+ attrs.lose_context_when_out_of_memory = true;
scoped_refptr<content::ContextProviderCommandBuffer> context_provider;
content::BrowserGpuChannelHostFactory* factory =
content::BrowserGpuChannelHostFactory::instance();
content::CauseForGpuLaunch cause = content::
CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
- scoped_refptr<content::GpuChannelHost> gpu_channel_host(
+ scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
factory->EstablishGpuChannelSync(cause));
if (gpu_channel_host.get() && !gpu_channel_host->IsLost()) {
context_provider = content::ContextProviderCommandBuffer::Create(
CreateGpuProcessViewContext(gpu_channel_host, attrs, 0),
- content::BROWSER_COMPOSITOR_ONSCREEN_CONTEXT);
+ content::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
}
if (!context_provider.get()) {
LOG(ERROR) << "Failed to create 3D context for compositor.";
if (shared_main_thread_contexts_.get())
return shared_main_thread_contexts_;
- blink::WebGraphicsContext3D::Attributes attrs;
- attrs.depth = false;
- attrs.stencil = false;
- attrs.antialias = false;
- attrs.shareResources = true;
- attrs.noAutomaticFlushes = true;
+ gpu::gles2::ContextCreationAttribHelper attrs;
+ attrs.alpha_size = -1;
+ attrs.depth_size = 0;
+ attrs.stencil_size = 0;
+ attrs.samples = 0;
+ attrs.sample_buffers = 0;
+ attrs.bind_generates_resource = false;
+ attrs.lose_context_when_out_of_memory = true;
scoped_refptr<content::ContextProviderCommandBuffer> context_provider;
content::BrowserGpuChannelHostFactory* factory =
content::BrowserGpuChannelHostFactory::instance();
content::CauseForGpuLaunch cause = content::
CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
- scoped_refptr<content::GpuChannelHost> gpu_channel_host(
+ scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
factory->EstablishGpuChannelSync(cause));
if (gpu_channel_host.get() && !gpu_channel_host->IsLost()) {
shared_main_thread_contexts_ =
return true;
}
-CommandBufferProxyImpl* MailboxOutputSurfaceEfl::GetCommandBufferProxy() {
+gpu::CommandBufferProxyImpl* MailboxOutputSurfaceEfl::GetCommandBufferProxy() {
ContextProviderCommandBuffer* provider_command_buffer =
static_cast<ContextProviderCommandBuffer*>(context_provider_.get());
- CommandBufferProxyImpl* command_buffer_proxy =
+ gpu::CommandBufferProxyImpl* command_buffer_proxy =
provider_command_buffer->GetCommandBufferProxy();
DCHECK(command_buffer_proxy);
return command_buffer_proxy;
#include "cc/output/gl_frame_data.h"
#include "cc/output/output_surface.h"
#include "cc/resources/resource_format.h"
-#include "content/common/gpu/client/command_buffer_proxy_impl.h"
#include "content/common/gpu/client/context_provider_command_buffer.h"
+#include "gpu/ipc/client/command_buffer_proxy_impl.h"
#include "ui/gfx/swap_result.h"
#include "ui/compositor/compositor.h"
private:
void OnSwapAck(scoped_ptr<cc::GLFrameData> gl_frame_data);
void DrawTexture(scoped_ptr<cc::GLFrameData> gl_frame_data);
- CommandBufferProxyImpl* GetCommandBufferProxy();
+ gpu::CommandBufferProxyImpl* GetCommandBufferProxy();
void OnSwapBuffersCompleted(const std::vector<ui::LatencyInfo>& latency_info,
gfx::SwapResult result);
} // namespace content
-#endif // CONTENT_BROWSER_COMPOSITOR_MAILBOX_OUTPUT_SURFACE_EFL_H_
\ No newline at end of file
+#endif // CONTENT_BROWSER_COMPOSITOR_MAILBOX_OUTPUT_SURFACE_EFL_H_
void DataFetcherImplTizen::SetOrientationBufferReadyStatus(bool ready) {
device_orientation_buffer_->seqlock.WriteBegin();
device_orientation_buffer_->data.absolute = ready;
- device_orientation_buffer_->data.hasAbsolute = ready;
device_orientation_buffer_->data.allAvailableSensorsAreActive = ready;
device_orientation_buffer_->seqlock.WriteEnd();
is_orientation_buffer_ready_ = ready;
#include "base/thread_task_runner_handle.h"
#include "base/logging.h"
#include "base/strings/utf_string_conversions.h"
-#include "content/common/view_messages.h"
-#include "content/browser/compositor/resize_lock.h"
+#include "content/browser/compositor/gl_helper.h"
#include "content/browser/gpu/browser_gpu_channel_host_factory.h"
#include "content/browser/gpu/compositor_util.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/renderer_host/resize_lock.h"
#include "content/browser/renderer_host/ui_events_helper.h"
#include "content/browser/renderer_host/im_context_efl.h"
#include "content/browser/renderer_host/edge_effect.h"
#include "content/browser/renderer_host/input/web_input_event_util.h"
#include "content/browser/renderer_host/render_view_host_impl.h"
#include "content/browser/gpu/gpu_process_host.h"
-#include "content/common/gpu/client/gl_helper.h"
#include "content/common/input/did_overscroll_params.h"
#include "content/common/input_messages.h"
-#include "content/common/gpu/gpu_messages.h"
#include "content/common/cursors/webcursor_efl.h"
+#include "content/common/view_messages.h"
#include "content/gpu/shared_mailbox_manager.h"
#include "content/public/browser/render_widget_host_view_frame_subscriber.h"
#include "content/public/browser/screen_orientation_dispatcher_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/common/content_switches.h"
#include "gpu/command_buffer/service/mailbox_manager.h"
+#include "gpu/ipc/common/gpu_messages.h"
+#include "media/base/video_frame.h"
#include "media/base/video_util.h"
#include "skia/ext/image_operations.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
im_context_->HandleKeyEvent(processed);
}
-void RenderWidgetHostViewEfl::MovePluginWindows(
- const std::vector<WebPluginGeometry>& moves) {
-}
-
void RenderWidgetHostViewEfl::UpdateCursor(const WebCursor& webcursor) {
if (is_loading_) {
// Setting native Loading cursor
}
void RenderWidgetHostViewEfl::TextInputStateChanged(
- const ViewHostMsg_TextInputState_Params& params) {
-
+ const TextInputState& params) {
if (!params.show_ime_if_needed) {
WebContentsImpl* wci = static_cast<WebContentsImpl*>(&web_contents_);
WebContentsViewEfl* wcve = static_cast<WebContentsViewEfl*>(wci->GetView());
yuv_readback_pipeline->scaler()->SrcSubrect() != result_rect ||
yuv_readback_pipeline->scaler()->DstSize() != region_in_frame.size()) {
GLHelper::ScalerQuality quality = GLHelper::SCALER_QUALITY_FAST;
- std::string quality_switch = switches::kTabCaptureDownscaleQuality;
// If we're scaling up, we can use the "best" quality.
if (result_rect.size().width() < region_in_frame.size().width() &&
result_rect.size().height() < region_in_frame.size().height())
- quality_switch = switches::kTabCaptureUpscaleQuality;
-
- std::string switch_value =
- base::CommandLine::ForCurrentProcess()->
- GetSwitchValueASCII(quality_switch);
- if (switch_value == "fast")
- quality = GLHelper::SCALER_QUALITY_FAST;
- else if (switch_value == "good")
- quality = GLHelper::SCALER_QUALITY_GOOD;
- else if (switch_value == "best")
quality = GLHelper::SCALER_QUALITY_BEST;
rwhvefl->yuv_readback_pipeline_.reset(
#include "cc/resources/single_release_callback.h"
#include "cc/resources/texture_mailbox.h"
#include "content/browser/accessibility/browser_accessibility_manager.h"
-#include "content/browser/compositor/delegated_frame_host.h"
#include "content/browser/compositor/image_transport_factory.h"
#include "content/browser/compositor/owned_mailbox.h"
+#include "content/browser/renderer_host/delegated_frame_host.h"
#include "content/browser/renderer_host/render_widget_host_view_base.h"
#include "content/browser/selection/selection_controller_efl.h"
#include "gpu/command_buffer/common/mailbox.h"
typedef EvasGLuint64 GLuint64;
#endif
-struct ViewHostMsg_TextInputState_Params;
+struct TextInputState;
namespace ui {
class Compositor;
void UnlockMouse() override;
void Focus() override;
bool HasFocus() const override;
- void MovePluginWindows(
- const std::vector<WebPluginGeometry>&) override;
void UpdateCursor(const WebCursor&) override;
void SetIsLoading(bool) override;
+#if defined(EWK_BRINGUP)
+ // [M51_2704] TextInputStateChanged() should be removed and its functionality
+ // should be moved/implemented in appropriate place based on
+ // upstream commit : https://codereview.chromium.org/1652483002,
+ // as it may introduce regression.
// Updates the state of the input method attached to the view.
- void TextInputStateChanged(
- const ViewHostMsg_TextInputState_Params& params) override;
+ void TextInputStateChanged(const TextInputState& params);
+#endif
void OnTextInputInFormStateChanged(bool is_in_form_tag);
int route_id,
int main_frame_route_id,
const ViewHostMsg_CreateWindow_Params& params,
- SessionStorageNamespace* session_storage_namespace,
+ scoped_refptr<SessionStorageNamespace> session_storage_namespace,
bool create) {
-
if (create) {
scoped_refptr<SessionStorageNamespace> ssn = session_storage_namespace;
WebContentsEflDelegate::WebContentsCreateCallback callback = base::Bind(
int route_id,
int main_frame_route_id,
const ViewHostMsg_CreateWindow_Params& params,
- SessionStorageNamespace* session_storage_namespace,
+ scoped_refptr<SessionStorageNamespace> session_storage_namespace,
void* platform_data) {
bool is_guest = BrowserPluginGuest::IsGuest(this);
scoped_refptr<SiteInstance> site_instance =
NOTREACHED();
}
new_contents->GetController().SetSessionStorageNamespace(
- partition_id,
- session_storage_namespace);
+ partition_id, session_storage_namespace.get());
// Added for EFL port
new_contents->platform_data_ = platform_data;
#ifndef WEB_CONTENTS_IMPL_EFL_H_
#define WEB_CONTENTS_IMPL_EFL_H_
+#include "base/memory/ref_counted.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/common/content_export.h"
int route_id,
int main_frame_route_id,
const ViewHostMsg_CreateWindow_Params& params,
- SessionStorageNamespace* session_storage_namespace,
+ scoped_refptr<SessionStorageNamespace> session_storage_namespace,
bool create);
WebContents* HandleNewWebContentsCreate(
int route_id,
int main_frame_route_id,
const ViewHostMsg_CreateWindow_Params& params,
- SessionStorageNamespace* session_storage_namespace,
+ scoped_refptr<SessionStorageNamespace> session_storage_namespace,
void* platform_data);
bool UpdateTitleForEntry(NavigationEntryImpl* entry,
#include <Evas.h>
+#include "base/memory/scoped_ptr.h"
#include "content/browser/renderer_host/render_view_host_delegate_view.h"
#include "content/browser/web_contents/web_contents_view.h"
#include "content/common/content_export.h"
#include <Elementary.h>
#include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
#include "base/strings/string16.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/WebKit/public/web/WebDragOperation.h"
+++ /dev/null
-// 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 "content/child/npapi/webplugin_delegate_impl.h"
-
-#include "content/child/npapi/plugin_instance.h"
-#include "content/common/cursors/webcursor.h"
-
-using blink::WebInputEvent;
-
-namespace content {
-
-WebPluginDelegateImpl::WebPluginDelegateImpl(WebPlugin* plugin,
- PluginInstance* instance) {
-}
-
-WebPluginDelegateImpl::~WebPluginDelegateImpl() {
-}
-
-bool WebPluginDelegateImpl::PlatformInitialize() {
- return true;
-}
-
-void WebPluginDelegateImpl::PlatformDestroyInstance() {
- // Nothing to do here.
-}
-
-void WebPluginDelegateImpl::Paint(SkCanvas* canvas, const gfx::Rect& rect) {
-}
-
-bool WebPluginDelegateImpl::WindowedCreatePlugin() {
- return true;
-}
-
-void WebPluginDelegateImpl::WindowedDestroyWindow() {
-}
-
-bool WebPluginDelegateImpl::WindowedReposition(
- const gfx::Rect& window_rect,
- const gfx::Rect& clip_rect) {
- return true;
-}
-
-void WebPluginDelegateImpl::WindowedSetWindow() {
-}
-
-void WebPluginDelegateImpl::WindowlessUpdateGeometry(
- const gfx::Rect& window_rect,
- const gfx::Rect& clip_rect) {
-}
-
-void WebPluginDelegateImpl::WindowlessPaint(gfx::NativeDrawingContext context,
- const gfx::Rect& damage_rect) {
-}
-
-bool WebPluginDelegateImpl::PlatformSetPluginHasFocus(bool focused) {
- return true;
-}
-
-bool WebPluginDelegateImpl::PlatformHandleInputEvent(
- const WebInputEvent& event, WebCursor::CursorInfo* cursor_info) {
- return false;
-}
-
-} // namespace content
#include <cstdlib>
#include "base/environment.h"
-#include "base/path_service.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
+#include "base/memory/free_deleter.h"
#include "base/memory/scoped_ptr.h"
#include "base/nix/xdg_util.h"
+#include "base/path_service.h"
#include "build/tizen_version.h"
#if defined(OS_TIZEN)
+++ /dev/null
-# Copyright (c) 2015 Samsung Electronics. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-{
- 'sources': [
- 'child/npapi/webplugin_delegate_impl_efl.cc',
- ],
-}
# this implicitly means component="shared_library"
'includes': [
'content_browser_efl.gypi',
- 'content_child_efl.gypi',
'content_common_efl.gypi',
'content_gpu_efl.gypi',
'content_renderer_efl.gypi',
]
}],
- ['_target_name=="content_child"', {
- 'includes': [
- 'content_child_efl.gypi'
- ]
- }],
-
['_target_name=="content_shell_lib"', {
'sources': [
'shell/browser/shell_efl.cc',
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "content/common/gpu/gpu_host_messages.h"
+#include "content/common/gpu_host_messages.h"
#include "content/gpu/gpu_process.h"
#include "content/gpu/shared_mailbox_manager.h"
#include "ui/gl/gl_shared_context_efl.h"
namespace content {
struct GpuChildThreadEfl : public content::GpuChildThread {
- explicit GpuChildThreadEfl(const content::InProcessChildThreadParams& params,
+ explicit GpuChildThreadEfl(const gpu::GpuPreferences& gpu_preferences,
+ const content::InProcessChildThreadParams& params,
GpuMemoryBufferFactory* gpu_memory_buffer_factory,
gpu::SyncPointManager* sync_point_manager)
- : GpuChildThread(params, gpu_memory_buffer_factory, sync_point_manager) { }
+ : GpuChildThread(gpu_preferences,
+ params,
+ gpu_memory_buffer_factory,
+ sync_point_manager) {}
bool OnControlMessageReceived(const IPC::Message& msg) override {
bool handled = true;
return GpuChildThread::OnControlMessageReceived(msg);
}
- void OnInitialize() {
- GpuChildThread::OnInitialize();
+ void OnInitialize(const gpu::GpuPreferences& preferences) {
+ GpuChildThread::OnInitialize(preferences);
// Override GpuChannelManager's default shared group and mailbox instances.
gpu_channel_manager_->share_group_ =
};
struct InProcessGpuThreadEfl : public content::InProcessGpuThread {
-
- explicit InProcessGpuThreadEfl(const content::InProcessChildThreadParams& params,
- gpu::SyncPointManager* sync_point_manager_override)
- : InProcessGpuThread(params, sync_point_manager_override) { }
+ explicit InProcessGpuThreadEfl(
+ const content::InProcessChildThreadParams& params,
+ const gpu::GpuPreferences& gpu_preferences,
+ gpu::SyncPointManager* sync_point_manager_override)
+ : InProcessGpuThread(params,
+ gpu_preferences,
+ sync_point_manager_override) {}
void Init() override {
gpu_process_ = new content::GpuProcess(base::ThreadPriority::NORMAL);
// The process object takes ownership of the thread object, so do not
// save and delete the pointer.
- gpu_process_->set_main_thread(new GpuChildThreadEfl(params_,
- gpu_memory_buffer_factory_.get(),
- sync_point_manager_override_));
+ gpu_process_->set_main_thread(new GpuChildThreadEfl(
+ gpu_preferences_, params_, gpu_memory_buffer_factory_.get(),
+ sync_point_manager_override_));
}
};
-base::Thread* CreateInProcessGpuThread(const content::InProcessChildThreadParams& params) {
- return new InProcessGpuThreadEfl(params, nullptr);
+base::Thread* CreateInProcessGpuThread(
+ const content::InProcessChildThreadParams& params,
+ const gpu::GpuPreferences& gpu_preferences) {
+ return new InProcessGpuThreadEfl(params, gpu_preferences, nullptr);
}
} // namespace content
elm_win_resize_object_add(window, box);
evas_object_show(box);
- if (!base::CommandLine::ForCurrentProcess()->
- HasSwitch(switches::kRunLayoutTest))
+ if (!switches::IsRunLayoutTestSwitchPresent())
CreateURLBar(box);
Evas_Object* view = static_cast<Evas_Object*>(
JavaScriptDialogManager* Shell::GetJavaScriptDialogManager(WebContents* source) {
if (!dialog_manager_) {
- const base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
- if (command_line.HasSwitch(switches::kRunLayoutTest)) {
+ if (switches::IsRunLayoutTestSwitchPresent()) {
dialog_manager_.reset(new LayoutTestJavaScriptDialogManager);
} else {
dialog_manager_.reset(new JavaScriptDialogManagerEfl);
void ShellWebContentsViewDelegate::ShowContextMenu(
RenderFrameHost* render_frame_host,
const ContextMenuParams& params) {
- if (base::CommandLine::ForCurrentProcess()->
- HasSwitch(switches::kRunLayoutTest))
+ if (switches::IsRunLayoutTestSwitchPresent())
return;
if (g_context_menu) {
+++ /dev/null
-// Copyright (c) 2015 Samsung Electronics. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "media/ozone/media_ozone_platform.h"
-
-namespace media {
-
-namespace {
-
-class MediaOzonePlatformEfl : public MediaOzonePlatform {
- public:
- MediaOzonePlatformEfl() {}
- ~MediaOzonePlatformEfl() override {}
-
- private:
- DISALLOW_COPY_AND_ASSIGN(MediaOzonePlatformEfl);
-};
-
-} // namespace
-
-MediaOzonePlatform* CreateMediaOzonePlatformEfl() {
- return new MediaOzonePlatformEfl;
-}
-
-} // namespace media
'sources': [
'client_native_pixmap_factory_efl.h',
'client_native_pixmap_factory_efl.cc',
- 'media_ozone_platform_efl.cc',
'ozone_platform_efl.h',
'ozone_platform_efl.cc',
'surface_factory_efl.h',
using web_contents_utils::WebContentsFromFrameID;
using web_contents_utils::WebViewFromWebContents;
+using namespace blink::mojom;
namespace content {
#include "base/callback.h"
#include "base/memory/weak_ptr.h"
-#include "content/public/common/permission_status.mojom.h"
+#include "third_party/WebKit/public/platform/modules/permissions/permission_status.mojom.h"
class GURL;
// The renderer is requesting permission to use Geolocation.
// When the answer to a permission request has been determined, |callback|
// should be called with the result.
- void RequestPermission(int render_process_id,
- int render_frame_id,
- const GURL& requesting_frame,
- base::Callback<void(PermissionStatus)> callback) const;
+ void RequestPermission(
+ int render_process_id,
+ int render_frame_id,
+ const GURL& requesting_frame,
+ base::Callback<void(blink::mojom::PermissionStatus)> callback) const;
// The renderer is cancelling a pending permission request.
void CancelPermissionRequest(int render_process_id,
const GURL& requesting_frame) const;
private:
- void RequestPermissionOnUIThread(int render_process_id,
- int render_frame_id,
- const GURL& requesting_frame,
- base::Callback<void(PermissionStatus)> callback) const;
+ void RequestPermissionOnUIThread(
+ int render_process_id,
+ int render_frame_id,
+ const GURL& requesting_frame,
+ base::Callback<void(blink::mojom::PermissionStatus)> callback) const;
mutable base::WeakPtrFactory<GeolocationPermissionContextEfl>
weak_ptr_factory_;
void JavaScriptDialogManagerEfl::RunJavaScriptDialog(content::WebContents* web_contents,
const GURL& origin_url,
- const std::string& accept_lang,
content::JavaScriptMessageType javascript_message_type,
const base::string16& message_text,
const base::string16& default_prompt_text,
dialog_.reset(JavaScriptModalDialogEfl::CreateDialog(web_contents,
origin_url,
- accept_lang,
type,
message_text,
default_prompt_text,
}
void JavaScriptDialogManagerEfl::RunBeforeUnloadDialog(content::WebContents* web_contents,
- const base::string16& message_text,
bool is_reload,
const DialogClosedCallback& callback) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
wv->SmartCallback<EWebViewCallbacks::PopupReplyWaitStart>().call(0);
dialog_.reset(JavaScriptModalDialogEfl::CreateDialog(
- web_contents,
- GURL(),
- std::string(),
- JavaScriptModalDialogEfl::NAVIGATION,
+ web_contents, GURL(), JavaScriptModalDialogEfl::NAVIGATION,
base::UTF8ToUTF16(
std::string(dgettext("WebKit", "IDS_WEBVIEW_BEFOREUNLOAD_MESSAGE"))),
- message_text,
- callback));
+ base::string16(), callback));
}
virtual void RunJavaScriptDialog(
content::WebContents* web_contents,
const GURL& origin_url,
- const std::string& accept_lang,
content::JavaScriptMessageType javascript_message_type,
const base::string16& message_text,
const base::string16& default_prompt_text,
bool* did_suppress_message) override;
virtual void RunBeforeUnloadDialog(content::WebContents* web_contents,
- const base::string16& message_text,
bool is_reload,
const DialogClosedCallback& callback) override;
//static
JavaScriptModalDialogEfl* JavaScriptModalDialogEfl::CreateDialog(content::WebContents* web_contents,
const GURL& origin_url,
- const std::string& accept_lang,
Type type,
const base::string16& message_text,
const base::string16& default_prompt_text,
const content::JavaScriptDialogManager::DialogClosedCallback& callback) {
- JavaScriptModalDialogEfl* dialog = new JavaScriptModalDialogEfl(web_contents,
- origin_url, accept_lang, type, message_text, default_prompt_text, callback);
+ JavaScriptModalDialogEfl* dialog =
+ new JavaScriptModalDialogEfl(web_contents, origin_url, type, message_text,
+ default_prompt_text, callback);
if (!dialog->ShowJavaScriptDialog()) {
delete dialog;
dialog = NULL;
JavaScriptModalDialogEfl::JavaScriptModalDialogEfl(content::WebContents* web_contents,
const GURL& origin_url,
- const std::string& accept_lang,
Type type,
const base::string16& message_text,
const base::string16& default_prompt_text,
const content::JavaScriptDialogManager::DialogClosedCallback& callback)
: callback_(callback)
, origin_url_(origin_url)
- , accept_lang_(accept_lang)
, label_(false)
, type_(type)
, message_text_(message_text)
static void javascriptPopupResizeCallback(void *data, Evas *e, Evas_Object *obj, void *event_info);
static JavaScriptModalDialogEfl* CreateDialog(content::WebContents* web_contents,
const GURL& origin_url,
- const std::string& accept_lang,
Type type,
const base::string16& message_text,
const base::string16& default_prompt_text,
private:
JavaScriptModalDialogEfl(content::WebContents* web_contents,
const GURL& origin_url,
- const std::string& accept_lang,
Type type,
const base::string16& message_text,
const base::string16& default_prompt_text,
content::JavaScriptDialogManager::DialogClosedCallback callback_;
GURL origin_url_;
- std::string accept_lang_;
bool label_;
Type type_;
base::string16 message_text_;
#include "public/ewk_notification.h"
using web_contents_utils::WebViewFromWebContents;
+using namespace blink::mojom;
namespace content {
void NotificationControllerEfl::RequestPermission(
WebContents* web_contents,
const GURL& requesting_frame,
- const base::Callback<void(content::PermissionStatus)>& result_callback) {
-
+ const base::Callback<void(PermissionStatus)>& result_callback) {
EWebView* web_view = WebViewFromWebContents(web_contents);
if (!web_view) {
LOG(ERROR) << "Dropping PermissionNotification request caused by lack "
#include "base/synchronization/lock.h"
#include "content/public/browser/desktop_notification_delegate.h"
#include "content/public/browser/platform_notification_service.h"
-#include "content/public/common/permission_status.mojom.h"
#include "public/ewk_notification.h"
+#include "third_party/WebKit/public/platform/modules/permissions/permission_status.mojom.h"
#include "url/gurl.h"
namespace content {
void RequestPermission(WebContents* web_contents,
const GURL& requesting_frame,
- const base::Callback<void(PermissionStatus)>& result_callback);
+ const base::Callback<void(
+ blink::mojom::PermissionStatus)>& result_callback);
void SetNotificationCallbacks(Ewk_Notification_Show_Callback show_callback,
Ewk_Notification_Cancel_Callback close_callback, void* user_data);
#include "content/public/browser/web_contents.h"
#include "ewk_global_data.h"
+using namespace blink::mojom;
+
namespace content {
PermissionManagerEfl::PermissionManagerEfl() {
PermissionType permission,
content::RenderFrameHost* render_frame_host,
const GURL& requesting_origin,
- const base::Callback<void(PermissionStatus)>& callback) override;
+ const base::Callback<void(blink::mojom::PermissionStatus)>& callback)
+ override;
int RequestPermissions(
const std::vector<PermissionType>& permission,
RenderFrameHost* render_frame_host,
const GURL& requesting_origin,
- const base::Callback<void(
- const std::vector<PermissionStatus>&)>& callback) override;
+ const base::Callback<
+ void(const std::vector<blink::mojom::PermissionStatus>&)>& callback)
+ override;
void CancelPermissionRequest(int request_id) override;
- PermissionStatus GetPermissionStatus(
+ blink::mojom::PermissionStatus GetPermissionStatus(
PermissionType permission,
const GURL& requesting_origin,
const GURL& embedding_origin) override;
// pair { requesting_origin, embedding_origin } changes.
// Returns the subscription_id to be used to unsubscribe.
int SubscribePermissionStatusChange(
- PermissionType permission,
- const GURL& requesting_origin,
- const GURL& embedding_origin,
- const base::Callback<void(PermissionStatus)>& callback) override;
+ PermissionType permission,
+ const GURL& requesting_origin,
+ const GURL& embedding_origin,
+ const base::Callback<void(blink::mojom::PermissionStatus)>& callback)
+ override;
void UnsubscribePermissionStatusChange(int subscription_id) override;
#ifndef Vibration_Provider_Client_h
#define Vibration_Provider_Client_h
+#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "device/vibration/vibration_provider_client.h"
#include "public/ewk_context.h"
PrefRegistrySimple* pref_registry = new PrefRegistrySimple();
pref_registry->RegisterBooleanPref(kAutofillEnabled, true);
- pref_registry->RegisterBooleanPref(kAutofillWalletSyncExperimentEnabled, false);
pref_registry->RegisterBooleanPref(kAutofillWalletImportEnabled, true);
pref_registry->RegisterBooleanPref(kPasswordManagerSavingEnabled, true);
autofill::PersonalDataManagerFactory::GetInstance()
->PersonalDataManagerAdd(this);
#endif
+ BrowserContext::Initialize(this, GetPath());
}
net::URLRequestContextGetter* BrowserContextEfl::GetRequestContext() {
virtual net::URLRequestContextGetter* GetRequestContext() override;
URLRequestContextGetterEfl* GetRequestContextEfl()
{ return request_context_getter_.get(); }
- virtual net::URLRequestContextGetter* GetRequestContextForRenderProcess(int) override
- { return GetRequestContext(); }
virtual net::URLRequestContextGetter* GetMediaRequestContext() override
{ return GetRequestContext(); }
virtual net::URLRequestContextGetter* GetMediaRequestContextForRenderProcess(int) override
net::URLRequestContextGetter* CreateRequestContext(
content::ProtocolHandlerMap* protocol_handlers,
URLRequestInterceptorScopedVector request_interceptors);
+
+ virtual net::URLRequestContextGetter* CreateRequestContextForStoragePartition(
+ const base::FilePath& partition_path,
+ bool in_memory,
+ ProtocolHandlerMap* protocol_handlers,
+ URLRequestInterceptorScopedVector request_interceptors) override {
+ return nullptr;
+ }
+
void SetCertificate(const char* certificate_file);
EWebContext* WebContext() const
{ return web_context_; }
#ifndef CONTENT_BROWSER_MAIN_PARTS_EFL_H_
#define CONTENT_BROWSER_MAIN_PARTS_EFL_H_
+#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "content/public/browser/browser_main_parts.h"
#include <string>
+#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "build/tizen_version.h"
return browser_main_parts_efl_;
}
-net::URLRequestContextGetter* ContentBrowserClientEfl::CreateRequestContext(
- BrowserContext* browser_context,
- ProtocolHandlerMap* protocol_handlers,
- URLRequestInterceptorScopedVector request_interceptors) {
- return static_cast<BrowserContextEfl*>(browser_context)
- ->CreateRequestContext(protocol_handlers,
- std::move(request_interceptors));
-}
-
AccessTokenStore* ContentBrowserClientEfl::CreateAccessTokenStore() {
return new AccessTokenStoreEfl();
}
#ifndef CONTENT_BROWSER_CLIENT_EFL
#define CONTENT_BROWSER_CLIENT_EFL
+#include "content/public/browser/browser_context.h"
#include "content/public/browser/content_browser_client.h"
#include "third_party/WebKit/public/platform/modules/notifications/WebNotificationPermission.h"
virtual BrowserMainParts* CreateBrowserMainParts(
const MainFunctionParams& parameters) override;
- virtual net::URLRequestContextGetter* CreateRequestContext(
- BrowserContext* browser_context,
- ProtocolHandlerMap* protocol_handlers,
- URLRequestInterceptorScopedVector request_interceptors) override;
-
virtual AccessTokenStore* CreateAccessTokenStore() override;
#if defined(OS_TIZEN)
virtual LocationProvider* OverrideSystemLocationProvider() override;
save_fail_dialog_.reset(JavaScriptModalDialogEfl::CreateDialog(
&web_contents_,
GURL(),
- std::string(),
JavaScriptModalDialogEfl::ALERT,
base::UTF8ToUTF16(std::string(dgettext("WebKit", "IDS_WEBVIEW_POP_FAIL"))),
base::string16(),
file_saved_dialog_.reset(JavaScriptModalDialogEfl::CreateDialog(
&web_contents_,
GURL(),
- std::string(),
JavaScriptModalDialogEfl::ALERT,
base::UTF8ToUTF16(std::string(dgettext("WebKit", "IDS_WEBVIEW_POP_SAVED"))),
base::string16(),
break;
}
case EWK_CONTEXT_MENU_ITEM_TAG_RELOAD: {
- webview_->ReloadIgnoringCache();
+ webview_->ReloadBypassingCache();
break;
}
case EWK_CONTEXT_MENU_ITEM_TAG_COPY: {
void CookieManager::DeleteSessionCookiesOnIOThread() {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
- scoped_refptr<net::CookieStore> cookie_store = GetCookieStore();
+ scoped_ptr<net::CookieStore> cookie_store = GetCookieStore();
if (cookie_store.get())
cookie_store->DeleteSessionCookiesAsync(base::Callback<void(int)>());
}
-static void DeleteCookiesOnIOThread(scoped_refptr<net::CookieStore> cookie_store,
+static void DeleteCookiesOnIOThread(scoped_ptr<net::CookieStore> cookie_store,
const std::string& url,
const std::string& cookie_name) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
const std::string& cookie_name)
{
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- scoped_refptr<net::CookieStore> cookie_store = GetCookieStore();
+ scoped_ptr<net::CookieStore> cookie_store = GetCookieStore();
if (cookie_store.get()) {
- BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
- base::Bind(DeleteCookiesOnIOThread,
- cookie_store,
- url,
- cookie_name));
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(DeleteCookiesOnIOThread,
+ base::Passed(std::move(cookie_store)), url, cookie_name));
}
}
void CookieManager::GetHostNamesWithCookiesAsync(AsyncHostnamesGetCb callback, void *data) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
host_callback_queue_.push(new EwkGetHostCallback(callback, data));
- scoped_refptr<net::CookieStore> cookie_store = GetCookieStore();
+ scoped_ptr<net::CookieStore> cookie_store = GetCookieStore();
if (cookie_store.get()) {
- BrowserThread::PostTask(BrowserThread::IO,
- FROM_HERE,
- base::Bind(&CookieManager::FetchCookiesOnIOThread,
- GetSharedThis(),
- cookie_store));
+ BrowserThread::PostTask(
+ BrowserThread::IO, FROM_HERE,
+ base::Bind(&CookieManager::FetchCookiesOnIOThread, GetSharedThis(),
+ base::Passed(std::move(cookie_store))));
}
}
-void CookieManager::FetchCookiesOnIOThread(scoped_refptr<net::CookieStore> cookie_store) {
+void CookieManager::FetchCookiesOnIOThread(
+ scoped_ptr<net::CookieStore> cookie_store) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
if (cookie_store.get()) {
completion->Signal();
}
-static void GetCookieValueOnIOThread(scoped_refptr<net::CookieStore> cookie_store,
+static void GetCookieValueOnIOThread(scoped_ptr<net::CookieStore> cookie_store,
const GURL& host,
std::string* result,
base::WaitableEvent* completion) {
std::string CookieManager::GetCookiesForURL(const std::string& url) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- scoped_refptr<net::CookieStore> cookie_store = GetCookieStore();
+ scoped_ptr<net::CookieStore> cookie_store = GetCookieStore();
if (!cookie_store.get())
return std::string();
base::WaitableEvent completion(false, false);
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(GetCookieValueOnIOThread,
- cookie_store,
- GURL(url),
- &cookie_value,
- &completion));
+ base::Passed(std::move(cookie_store)),
+ GURL(url), &cookie_value, &completion));
// allow wait temporarily.
ScopedAllowWaitForLegacyWebViewApi allow_wait;
completion.Wait();
return scoped_refptr<content::URLRequestContextGetterEfl>(request_context_getter_.get());
}
-scoped_refptr<net::CookieStore> CookieManager::GetCookieStore() const {
+scoped_ptr<net::CookieStore> CookieManager::GetCookieStore() const {
scoped_refptr<content::URLRequestContextGetterEfl> request_context_getter = GetContextGetter();
if (request_context_getter.get()) {
- return request_context_getter->
- GetURLRequestContext()->
- cookie_store();
+ return scoped_ptr<net::CookieStore>(
+ request_context_getter->GetURLRequestContext()->cookie_store());
} else {
- return scoped_refptr<net::CookieStore>();
+ return scoped_ptr<net::CookieStore>();
}
}
const GURL& first_party_url,
bool setting_cookie);
// Fetch the cookies. This must be called in the IO thread.
- void FetchCookiesOnIOThread(scoped_refptr<net::CookieStore> cookie_store);
+ void FetchCookiesOnIOThread(scoped_ptr<net::CookieStore> cookie_store);
void OnFetchComplete(const net::CookieList& cookies);
scoped_refptr<CookieManager> GetSharedThis();
scoped_refptr<content::URLRequestContextGetterEfl> GetContextGetter() const;
- scoped_refptr<net::CookieStore> GetCookieStore() const;
+ scoped_ptr<net::CookieStore> GetCookieStore() const;
scoped_refptr<content::URLRequestContextGetterEfl> request_context_getter_;
//cookie policy information
base::Lock lock_;
void EWebContext::AddExtraPluginDir(const char *path) {
#if defined(ENABLE_PLUGINS)
+#if !defined(EWK_BRINGUP)
+ // [M51_2704] The AddExtraPluginDir API was removed in content::PluginList
+ // class. It will be fixed by webview team.
+ // FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-1132
content::PluginList::Singleton()->AddExtraPluginDir(base::FilePath(path));
+#endif // EWK_BRINGUP
#endif
}
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&SetProxyConfigCallbackOnIOThread, &done,
- make_scoped_refptr(browser_context()->GetRequestContext()),
+ base::RetainedRef(browser_context()->GetRequestContext()),
config));
done.Wait();
}
web_contents_->GetController().Reload(true);
}
-void EWebView::ReloadIgnoringCache() {
- web_contents_->GetController().ReloadIgnoringCache(true);
+void EWebView::ReloadBypassingCache() {
+ web_contents_->GetController().ReloadBypassingCache(true);
}
Eina_Bool EWebView::CanGoBack() {
void SetURL(const GURL& url);
const GURL& GetURL() const;
void Reload();
- void ReloadIgnoringCache();
+ void ReloadBypassingCache();
Eina_Bool CanGoBack();
Eina_Bool CanGoForward();
Eina_Bool HasFocus() const;
Name: chromium-ewk
Description: EWK API based on chromium-efl engine
-Version: 50.2661.0.14-1
+Version: 51.2704.0.17-1
Requires: chromium-efl
Libs: -L${libdir} -lchromium-ewk
Cflags: -I${includedir}/chromium-ewk
#include <content/public/browser/browser_thread.h>
using content::BrowserThread;
+using namespace blink::mojom;
_Ewk_Geolocation_Permission_Request::_Ewk_Geolocation_Permission_Request(
- const GURL& origin_url,
- base::Callback<void(content::PermissionStatus)> callback)
- : origin_(new _Ewk_Security_Origin(origin_url)),
- callback_(callback) {
-}
+ const GURL& origin_url,
+ base::Callback<void(PermissionStatus)> callback)
+ : origin_(new _Ewk_Security_Origin(origin_url)), callback_(callback) {}
_Ewk_Geolocation_Permission_Request::~_Ewk_Geolocation_Permission_Request() {
CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
}
void _Ewk_Geolocation_Permission_Request::runCallback(bool allowed) {
- callback_.Run(allowed?
- content::PermissionStatus::GRANTED:
- content::PermissionStatus::DENIED);
+ callback_.Run(allowed ? PermissionStatus::GRANTED : PermissionStatus::DENIED);
}
#define ewk_geolocation_private_h
#include "base/callback.h"
-#include "content/public/common/permission_status.mojom.h"
#include "ewk_suspendable_object.h"
+#include "third_party/WebKit/public/platform/modules/permissions/permission_status.mojom.h"
#include "url/gurl.h"
class _Ewk_Security_Origin;
// to be called once the permission is determined by app.
class _Ewk_Geolocation_Permission_Request : public Ewk_Suspendable_Object{
public:
- _Ewk_Geolocation_Permission_Request(const GURL& origin_url,
- base::Callback<void(content::PermissionStatus)> callback);
+ _Ewk_Geolocation_Permission_Request(
+ const GURL& origin_url,
+ base::Callback<void(blink::mojom::PermissionStatus)> callback);
~_Ewk_Geolocation_Permission_Request();
_Ewk_Security_Origin* GetOrigin() const { return origin_; }
void runCallback(bool allowed) override;
- base::Callback<void(content::PermissionStatus)> callback_;
+ base::Callback<void(blink::mojom::PermissionStatus)> callback_;
};
#endif // ewk_geolocation_private_h
#include "third_party/skia/include/core/SkImageEncoder.h"
using content::BrowserThread;
+using namespace blink::mojom;
Ewk_Notification::Ewk_Notification(
const std::string& body,
Ewk_Notification_Permission_Request::Ewk_Notification_Permission_Request(
Evas_Object* webview,
- const base::Callback<void(content::PermissionStatus)>& callback,
+ const base::Callback<void(PermissionStatus)>& callback,
const GURL& source_origin)
- : webview_(webview)
- , origin_(new _Ewk_Security_Origin(source_origin))
- , callback_(callback)
- , decided_(false)
- , suspended_(false)
-{
-}
+ : webview_(webview),
+ origin_(new _Ewk_Security_Origin(source_origin)),
+ callback_(callback),
+ decided_(false),
+ suspended_(false) {}
Ewk_Notification_Permission_Request::~Ewk_Notification_Permission_Request() {
}
decided_ = true;
- callback_.Run(allow?
- content::PermissionStatus::GRANTED:
- content::PermissionStatus::DENIED);
+ callback_.Run(allow ? PermissionStatus::GRANTED : PermissionStatus::DENIED);
if (suspended_) {
// If decision was suspended, then it was not deleted by the creator
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
-#include "content/public/common/permission_status.mojom.h"
#include "private/ewk_security_origin_private.h"
#include "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/WebKit/public/platform/modules/permissions/permission_status.mojom.h"
class GURL;
struct Ewk_Notification_Permission_Request {
public:
- Ewk_Notification_Permission_Request(Evas_Object* webview,
- const base::Callback<void(content::PermissionStatus)>& callback,
- const GURL& source_origin);
+ Ewk_Notification_Permission_Request(
+ Evas_Object* webview,
+ const base::Callback<void(blink::mojom::PermissionStatus)>& callback,
+ const GURL& source_origin);
~Ewk_Notification_Permission_Request();
Evas_Object* GetWebviewEvasObject() const;
private:
Evas_Object* webview_;
scoped_ptr<_Ewk_Security_Origin> origin_;
- base::Callback<void(content::PermissionStatus)> callback_;
+ base::Callback<void(blink::mojom::PermissionStatus)> callback_;
bool decided_;
mutable bool suspended_;
Eina_Bool ewk_view_reload_bypass_cache(Evas_Object *view)
{
EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
- impl->ReloadIgnoringCache();
+ impl->ReloadBypassingCache();
return true;
}
using blink::WebRuntimeFeatures;
using content::RenderThread;
-RenderProcessObserverEfl::RenderProcessObserverEfl(ContentRendererClientEfl* content_client)
- : content_client_(content_client), webkit_initialized_(false) {
+RenderProcessObserverEfl::RenderProcessObserverEfl(
+ ContentRendererClientEfl* content_client)
+ : content_client_(content_client) {
const base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
if (command_line.HasSwitch(switches::kEnableViewMode))
WebRuntimeFeatures::enableCSSViewModeMediaFeature(true);
return handled;
}
-void RenderProcessObserverEfl::WebKitInitialized()
-{
- webkit_initialized_ = true;
- OnSetCache(pending_cache_params_);
-}
-
void RenderProcessObserverEfl::OnClearCache()
{
WebCache::clear();
void RenderProcessObserverEfl::OnSetCache(const CacheParamsEfl& params)
{
- pending_cache_params_ = params;
- if(!webkit_initialized_)
- return;
-
WebCache::setCapacities(static_cast<size_t>(params.cache_min_dead_capacity),
static_cast<size_t>(params.cache_max_dead_capacity),
static_cast<size_t>(params.cache_total_capacity));
public:
explicit RenderProcessObserverEfl(ContentRendererClientEfl* content_client);
bool OnControlMessageReceived(const IPC::Message& message) override;
- void WebKitInitialized() override;
void OnClearCache();
private:
void OnSetCache(const CacheParamsEfl& params);
ContentRendererClientEfl* content_client_;
- bool webkit_initialized_;
- CacheParamsEfl pending_cache_params_;
};
#endif
#include "third_party/WebKit/public/web/WebFormElement.h"
#include "third_party/WebKit/public/web/WebFrame.h"
#include "third_party/WebKit/public/web/WebFrameContentDumper.h"
+#include "third_party/WebKit/public/web/WebFrameWidget.h"
#include "third_party/WebKit/public/web/WebHitTestResult.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"
void RenderViewObserverEfl::OnPlainTextGet(int plain_text_get_callback_id)
{
- blink::WebFrame* frame = render_view()->GetWebView()->mainFrame();
- if (!frame)
- return;
-
// WebFrameContentDumper should only be used for testing purposes. See http://crbug.com/585164.
- blink::WebString content = blink::WebFrameContentDumper::dumpFrameTreeAsText(frame->toWebLocalFrame(), INT_MAX);
+ blink::WebString content = blink::WebFrameContentDumper::dumpWebViewAsText(
+ render_view()->GetWebView(), INT_MAX);
Send(new EwkHostMsg_PlainTextGetContents(render_view()->GetRoutingID(), content.utf8(), plain_text_get_callback_id));
}
void RenderViewObserverEfl::OnSetDrawsTransparentBackground(bool draws_transparent_background)
{
- blink::WebView* view = render_view()->GetWebView();
- if (!view)
+ blink::WebFrameWidget* widget = render_view()->GetWebFrameWidget();
+ if (!widget)
return;
blink::WebColor backgroundColor = draws_transparent_background ?
static_cast<blink::WebColor>(0x00000000) : static_cast<blink::WebColor>(0xFFFFFFFF);
- view->setBaseBackgroundColor(backgroundColor);
+ widget->setBaseBackgroundColor(backgroundColor);
}
void RenderViewObserverEfl::OnWebAppIconUrlGet(int callback_id)
url_request_context_->ssl_config_service();
network_session_params.http_auth_handler_factory =
url_request_context_->http_auth_handler_factory();
- network_session_params.network_delegate =
- network_delegate_.get();
network_session_params.http_server_properties =
url_request_context_->http_server_properties();
network_session_params.net_log =
// Set the new cookie store that will be used for all new requests. The old
// cookie store, if any, will be automatically flushed and closed when no
// longer referenced.
- scoped_refptr<net::CookieMonster> cookie_monster =
- new net::CookieMonster(persistent_store.get(), NULL);
- storage_->set_cookie_store(cookie_monster.get());
+ scoped_ptr<net::CookieMonster> cookie_monster(
+ new net::CookieMonster(persistent_store.get(), NULL));
+ storage_->set_cookie_store(std::move(cookie_monster));
if (persistent_store.get() && persist_session_cookies)
cookie_monster->SetPersistSessionCookies(true);
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
+#include "content/public/browser/browser_context.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/content_browser_client.h"
#include "net/base/network_delegate.h"
#include "net/url_request/url_request_context_getter.h"
#include "net/url_request/url_request_context_storage.h"
#include "net/proxy/proxy_config_service.h"
+#include "net/url_request/url_request_job_factory_impl.h"
#include "public/ewk_cookie_manager.h"
namespace net {
net::NetLog* net_log_;
base::FilePath cookie_store_path_;
- scoped_refptr<net::CookieStore> cookie_store_;
+ scoped_ptr<net::CookieStore> cookie_store_;
scoped_ptr<net::HttpNetworkSession> http_network_session_;
scoped_ptr<net::ProxyConfigService> proxy_config_service_;
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="50.2661.0.14">
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="51.2704.0.17">
<label> mini browser application for chromium-efl package </label>
<author href="www.samsung.com" email="sns.park@samsung.com">SWC</author>
<description> mini browser application based on chromium-efl </description>
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.chromium-efl" version="50.2661.0.14">
+<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.chromium-efl" version="51.2704.0.17">
<label> mini browser application for chromium-efl package </label>
<author href="www.samsung.com" email="sns.park@samsung.com">SWC</author>
<description> mini browser application based on chromium-efl </description>
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="50.2661.0.14"
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="51.2704.0.17"
<label> micro browser application for chromium-efl package </label>
<author href="www.samsung.com" email="m.lapinski@samsung.com">SWC</author>
<description> micro browser application based on chromium-efl </description>
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.chromium-efl" version="50.2661.0.14">
+<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.chromium-efl" version="51.2704.0.17">
<label> micro browser application for chromium-efl package </label>
<author href="www.samsung.com" email="m.lapinski@samsung.com">SWC</author>
<description> micro browser application based on chromium-efl </description>
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="50.2661.0.14">
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="51.2704.0.17">
<label>uBrowser application for chromium-efl package</label>
<author href="www.samsung.com" email="p.tworek@samsung.com">SRPOL</author>
<description>Small reference browser application for chromium-efl port</description>
%define _binary_payload w3.gzdio
Name: chromium-efl-libs
-%define ChromiumVersion 50.2661.0
-%define Week 14
+%define ChromiumVersion 51.2704.0
+%define Week 17
Version: %{ChromiumVersion}.%{Week}
Release: 1
Summary: Chromium-based app runtime, private libraries
Name: chromium-efl
Summary: Chromium EFL
# Set by by scripts/update-chromium-version.sh
-%define ChromiumVersion 50.2661.0
-%define Week 14
+%define ChromiumVersion 51.2704.0
+%define Week 17
Version: %{ChromiumVersion}.%{Week}
Release: 1
# The 'Group' should be specified as one of the following valid group list.
%define _binary_payload w3.gzdio
Name: crosswalk-bin
-Version: 15.50.2661.0
+Version: 15.51.2704.0
Release: 0
Summary: Chromium-based app runtime
License: (BSD-3-Clause and LGPL-2.1+)
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Manifest xmlns="http://schemas.tizen.org/2012/12/manifest">
<Id>kmcele1k1p</Id>
- <Version>50.2661.0.14</Version>
+ <Version>51.2704.0.17</Version>
<Type>C++App</Type>
<Descriptions>
<Description Locale="eng-PH"/>
projects / platform / framework / web / chromium-efl.git / commitdiff