# SVN revision while Blink is still in SVN.
blink_upstream_rev = '191638' #TODO(TK) : need to update revision number
-efl_integration_branch = 'origin/dev/m51_2704'
+efl_integration_branch = 'origin/dev/m53_2785'
ct_git = 'ssh://165.213.202.130:29418/webplatform'
crosswalk_git = 'https://github.com/crosswalk-project'
ct_git + '/s-skia.git@' + efl_integration_branch,
'src/third_party/webrtc':
ct_git + '/s-webrtc.git@' + efl_integration_branch,
- 'src/third_party/libjingle/source/talk':
- ct_git + '/s-libjingle_source_talk.git@' + efl_integration_branch,
'src/v8':
ct_git + '/s-v8.git@' + efl_integration_branch,
export BUILD_EWK_UNITTESTS=0
export BUILD_CONTENT_SHELL=1
export BUILD_XWALK=0
- export BUILD_CHROMEDRIVER=0
export BUILD_SUBDIRECTORY=Release
export COMPONENT_BUILD=0
--xwalk)
export BUILD_XWALK=1
;;
- --chromedriver)
- export BUILD_CHROMEDRIVER=1
- ;;
--component-build)
export COMPONENT_BUILD=1
;;
if [[ $BUILD_XWALK == 1 ]]; then
TARGETS="$TARGETS xwalk"
fi
- if [[ $BUILD_CHROMEDRIVER == 1 ]]; then
- TARGETS="$TARGETS chromedriver"
- fi
BUILDDIR=${GYP_GENERATOR_OUTPUT}/${BUILD_SUBDIRECTORY}
ninja -C $BUILDDIR ${JOBS} ${TARGETS}
fi
--gbs-debug)
ARGS[$count]=--debug
;;
- --chromedriver)
- ARGS[$count]=--define
- count=$(( $count + 1 ))
- ARGS[$count]="build_chromedriver 1"
- ;;
--rpmlint)
RPMLINT=1
count=$(( $count + 1 ))
-Denable_extensions=1
-Duse_cups=0
-Duse_allocator=none
+ -Duse_libpci=0
-Ddisable_fatal_linker_warnings=
--depth=${TOPDIR}
"
<dependencies>
<dep package="libffi"/>
</dependencies>
- <branch module="/pub/GNOME/sources/glib/2.36/glib-2.36.0.tar.xz" version="2.36.0"
+ <branch module="/pub/GNOME/sources/glib/2.40/glib-2.40.2.tar.xz" version="2.40.2"
repo="ftp.gnome.org"
- hash="sha256:455a8abe8692c5174bcc7ffa15b96a7521a2f2f9fb47594405927c35cb9bb227"/>
+ hash="sha256:e8ff8af2950897e805408480c454c415d1eade4e670ec5fb507f5e5853726c7a"/>
</autotools>
<autotools id="glib-networking">
autogen-sh="configure"
autogenargs="--disable-examples --disable-tests --disable-failing-tests">
<branch repo="gstreamer"
- module="gstreamer/gstreamer-1.2.4.tar.xz" version="1.2.4"
- hash="sha256:1e7ca67a7870a82c9ed51d51d0008cdbc550c41d64cc3ff3f9a1c2fc311b4929">
+ module="gstreamer/gstreamer-1.6.2.tar.xz" version="1.6.2"
+ hash="sha256:5896716bd8e089dba452932a2eff2bb6f6c9d58ff64a96635d157f1ffaf8feb2">
</branch>
</autotools>
<dep package="gstreamer"/>
</dependencies>
<branch repo="gstreamer"
- module="gst-plugins-base/gst-plugins-base-1.2.4.tar.xz" version="1.2.4"
- hash="sha256:4d6273dc3f5a94bcc53ccfe0711cfddd49e31371d1136bf62fa1ecc604fc6550"/>
+ module="gst-plugins-base/gst-plugins-base-1.6.2.tar.xz" version="1.6.2"
+ hash="sha256:c75dd400e451526ed71e1c4955e33d470a2581f5e71ecf84920a41c0a5c75322"/>
</autotools>
<autotools id="gst-plugins-good"
<dep package="libsoup"/>
</dependencies>
<branch repo="gstreamer"
- module="gst-plugins-good/gst-plugins-good-1.2.4.tar.xz" version="1.2.4"
- hash="sha256:c9c90368393c2e5e78387e95c02ce7b19f48e793bba6d8547f2c4b51c6f420d3">
+ module="gst-plugins-good/gst-plugins-good-1.6.2.tar.xz" version="1.6.2"
+ hash="sha256:876e54dfce93274b98e024f353258d35fa4d49d1f9010069e676c530f6eb6a92">
</branch>
</autotools>
<dep package="gst-plugins-base"/>
</dependencies>
<branch repo="gstreamer"
- module="gst-plugins-ugly/gst-plugins-ugly-1.2.4.tar.xz" version="1.2.4"
- hash="sha256:4ef6f76a47d57b8385d457c7b620b4c28fc041ab1d7c2e3e2f5f05b12b988ea8"/>
+ module="gst-plugins-ugly/gst-plugins-ugly-1.6.2.tar.xz" version="1.6.2"
+ hash="sha256:e7f1b6321c8667fabc0dedce3998a3c6e90ce9ce9dea7186d33dc4359f9e9845"/>
</autotools>
<autotools id="gst-plugins-bad"
<dep package="gst-plugins-base"/>
</dependencies>
<branch repo="gstreamer"
- module="gst-plugins-bad/gst-plugins-bad-1.2.4.tar.xz" version="1.2.4"
- hash="sha256:984c133ec9d5d705e313d9e2bbd1472b93c6567460602a9a316578925ffe2eca">
+ module="gst-plugins-bad/gst-plugins-bad-1.6.2.tar.xz" version="1.6.2"
+ hash="sha256:650855e39ff56a8bb6cb0c192109c5926ce12f536d06e19ebf829de71ef396fe">
</branch>
</autotools>
<dep package="orc"/>
</dependencies>
<branch repo="gstreamer"
- module="gst-libav/gst-libav-1.2.4.tar.xz" version="1.2.4"
- hash="sha2546:2a69480d63fc2db93249d9e2e229ab3541bbc2db881b0f64de13d0bfc7d1f037">
+ module="gst-libav/gst-libav-1.6.2.tar.xz" version="1.6.2"
+ hash="sha2546:2597acc00171006d49f0d300440a87df51b113d557466e532153abc740db3469">
</branch>
</autotools>
--- /dev/null
+diff --git a/gpu/config/gpu_control_list.cc b/gpu/config/gpu_control_list.cc
+index 5561d32..7524e98 100644
+--- a/gpu/config/gpu_control_list.cc
++++ b/gpu/config/gpu_control_list.cc
+@@ -1034,8 +1034,14 @@ bool GpuControlList::GpuControlListEntry::SetFeatures(
+ if (supports_feature_type_all && feature_strings[i] == "all") {
+ for (FeatureMap::const_iterator iter = feature_map.begin();
+ iter != feature_map.end(); ++iter) {
++#if !defined(EWK_BRINGUP)
++// [M53_2785] Temporary disabling the codes for swiching to new chromium
++// The codes makes a build problem in mobile and tv target.
++// It will be fixed by rendering team.
++// FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2058
+ if (std::find(exception_strings.begin(), exception_strings.end(),
+ iter->first) == exception_strings.end())
++#endif // EWK_BRINGUP
+ features_.insert(iter->second);
+ }
+ continue;
+@@ -1044,8 +1050,14 @@ bool GpuControlList::GpuControlListEntry::SetFeatures(
+ features_.clear();
+ return false;
+ }
++#if !defined(EWK_BRINGUP)
++// [M53_2785] Temporary disabling the codes for swiching to new chromium
++// The codes makes a build problem in mobile and tv target.
++// It will be fixed by rendering team.
++// FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2058
+ if (std::find(exception_strings.begin(), exception_strings.end(),
+ feature_strings[i]) == exception_strings.end())
++#endif // EWK_BRINGUP
+ features_.insert(feature);
+ }
+ return true;
--- /dev/null
+diff --git a/tools/grit/grit/node/include.py b/tools/grit/grit/node/include.py
+index 4bad785..94e5e7a 100755
+--- a/tools/grit/grit/node/include.py
++++ b/tools/grit/grit/node/include.py
+@@ -100,10 +100,13 @@ class IncludeNode(base.Node):
+ # We only use rsyncable compression on Linux.
+ # We exclude ChromeOS since ChromeOS bots are Linux based but do not have
+ # the --rsyncable option built in for gzip. See crbug.com/617950.
+- if sys.platform == 'linux2' and 'chromeos' not in self.GetRoot().defines:
+- data = grit.format.gzip_string.GzipStringRsyncable(data)
+- else:
+- data = grit.format.gzip_string.GzipString(data)
++# [M53_2785] We cannot use the rsyncable compression since 'chromium-efl' do not
++# have the --rsyncable option built in for gzip.
++# FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2059
++# if sys.platform == 'linux2' and 'chromeos' not in self.GetRoot().defines:
++# data = grit.format.gzip_string.GzipStringRsyncable(data)
++# else:
++ data = grit.format.gzip_string.GzipString(data)
+ data = self.RESERVED_HEADER[0] + data
+ elif data[:3] == self.RESERVED_HEADER:
+ # We are reserving these 3 bytes as the header for gzipped files in the
--- /dev/null
+diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
+index 140e2fc..426bd43 100644
+--- a/content/renderer/render_view_impl.cc
++++ b/content/renderer/render_view_impl.cc
+@@ -208,6 +208,7 @@
+ #endif
+
+ #if defined(USE_EFL)
++#include "content/renderer/android/disambiguation_popup_helper.h"
+ #include "content/renderer/android/email_detector.h"
+ #include "content/renderer/android/phone_number_detector.h"
+ #include "ui/gfx/device_display_info_efl.h"
+@@ -3272,6 +3273,12 @@ bool RenderViewImpl::didTapMultipleTargets(
+ // The touch_rect, target_rects and zoom_rect are in the outer viewport
+ // reference frame.
+ gfx::Rect zoom_rect;
++#if !defined(EWK_BRINGUP)
++// [M53_2785] The path of "DisambiguationPopupHelper::ComputeZoomAreaAndScaleFactor"
++// is changed to "content/renderer/android/disambiguation_popup_helper.h"
++// from "content/renderer/disambiguation_popup_helper.h".
++// It will be fixed by webview team.
++// FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2057
+ float new_total_scale =
+ #if defined(S_TERRACE_SUPPORT)
+ DisambiguationPopupHelper::ComputeZoomAreaAndScaleFactor(
+@@ -3285,6 +3292,9 @@ bool RenderViewImpl::didTapMultipleTargets(
+ gfx::Rect(webview()->mainFrame()->visibleContentRect()).size(),
+ device_scale_factor_ * webview()->pageScaleFactor(), &zoom_rect);
+ #endif
++#else
++ float new_total_scale;
++#endif // EWK_BRINGUP
+ if (!new_total_scale || zoom_rect.IsEmpty())
+ return false;
+
+++ /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.
-
-{
- 'target_defaults': {
- 'target_conditions': [
- ['_target_name=="chromedriver_lib"', {
- 'sources/': [
- ['exclude', 'test/chromedriver/keycode_text_conversion_win\\.cc$'],
- ],
- 'conditions': [
- ['use_wayland==1', {
- 'sources/': [
- ['exclude', 'test/chromedriver/keycode_text_conversion_x\\.cc$'],
- ],
- }], # use_wayland==1
- ], # conditions
- }],
- ], # target_conditions
- }, # target_defaults
-}
{
'includes': [
'base/base_efl.gypi',
- 'chrome/chrome_tests_efl.gypi',
'content/content_efl.gypi',
'device/vibration_efl.gypi',
'gpu/gpu_efl.gypi',
'third_party/WebKit/Source/platform/blink_platform_efl.gypi',
],
- 'conditions': [
- ['building_for_tizen_mobile==1', {
- 'includes': [
- 'device/battery_tizen.gypi',
- ],
- }], # building_for_tizen_mobile==1
- ], # conditions
+# [M53_2785] Temporary disabling the codes for switching to new chromium
+# It will be fixed by Webcore Team.
+# FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2062
+# 'conditions': [
+# ['building_for_tizen_mobile==1', {
+# 'includes': [
+# 'device/battery_tizen.gypi',
+# ],
+# }], # building_for_tizen_mobile==1
+# ], # conditions
}
#include "content/browser/compositor/context_factory_efl.h"
+#include "cc/output/texture_mailbox_deleter.h"
#include "cc/raster/single_thread_task_graph_runner.h"
-#include "cc/surfaces/onscreen_display_client.h"
+#include "cc/surfaces/display.h"
#include "cc/surfaces/surface_display_output_surface.h"
-#include "content/browser/compositor/gl_helper.h"
+#include "components/display_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"
};
}
-static scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
-CreateGpuProcessViewContext(
- 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 share_resources = true;
- bool automatic_flushes = false;
- return make_scoped_ptr(new WebGraphicsContext3DCommandBufferImpl(
- surface_handle, url, gpu_channel_host.get(), attributes,
- gfx::PreferIntegratedGpu, share_resources, automatic_flushes,
- WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(), NULL));
-}
-
ContextFactoryEfl::ContextFactoryEfl()
: next_surface_id_namespace_(1u),
task_graph_runner_(new cc::SingleThreadTaskGraphRunner) {
- surface_manager_ = make_scoped_ptr(new cc::SurfaceManager);
+ surface_manager_ = base::WrapUnique(new cc::SurfaceManager);
task_graph_runner_->Start("CompositorTileWorker1",
base::SimpleThread::Options());
}
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<gpu::GpuChannelHost> gpu_channel_host(
- factory->EstablishGpuChannelSync(cause));
+ BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(
+ CAUSE_FOR_GPU_LAUNCH_BROWSER_SHARED_MAIN_THREAD_CONTEXT));
if (gpu_channel_host.get() && !gpu_channel_host->IsLost()) {
- context_provider = content::ContextProviderCommandBuffer::Create(
- CreateGpuProcessViewContext(gpu_channel_host, attrs, 0),
- content::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
+ GURL url("chrome://gpu/Compositor::createContext3D");
+ constexpr bool automatic_flushes = false;
+ constexpr bool support_locking = false;
+ constexpr gl::GpuPreference gpu_preference = gl::PreferIntegratedGpu;
+ context_provider = new content::ContextProviderCommandBuffer(
+ std::move(gpu_channel_host), gpu::GPU_STREAM_DEFAULT,
+ gpu::GpuStreamPriority::NORMAL, gpu::kNullSurfaceHandle, url,
+ gpu_preference, automatic_flushes, support_locking,
+ gpu::SharedMemoryLimits(), attrs, NULL,
+ command_buffer_metrics::DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
}
if (!context_provider.get()) {
LOG(ERROR) << "Failed to create 3D context for compositor.";
- compositor->SetOutputSurface(scoped_ptr<cc::OutputSurface>());
+ compositor->SetOutputSurface(std::unique_ptr<cc::OutputSurface>());
+ }
+
+ std::unique_ptr<cc::SyntheticBeginFrameSource> begin_frame_source;
+ if (!compositor->GetRendererSettings().disable_display_vsync) {
+ begin_frame_source.reset(new cc::DelayBasedBeginFrameSource(
+ base::MakeUnique<cc::DelayBasedTimeSource>(
+ compositor->task_runner().get())));
+ } else {
+ begin_frame_source.reset(new cc::BackToBackBeginFrameSource(
+ base::MakeUnique<cc::DelayBasedTimeSource>(
+ compositor->task_runner().get())));
}
- scoped_ptr<MailboxOutputSurfaceEfl> real_output_surface = make_scoped_ptr(
- new MailboxOutputSurfaceEfl(context_provider, cc::RGBA_8888));
- real_output_surface->SetCompositorClient(compositor->client());
+ std::unique_ptr<MailboxOutputSurfaceEfl> display_output_surface =
+ base::WrapUnique(
+ new MailboxOutputSurfaceEfl(context_provider, cc::RGBA_8888));
+ display_output_surface->SetCompositorClient(compositor->client());
+
+ std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
+ begin_frame_source.get(), compositor->task_runner().get(),
+ display_output_surface->capabilities().max_frames_pending));
cc::SurfaceManager* surface_manager = surface_manager_.get();
- display_client_.reset(new cc::OnscreenDisplayClient(
- std::move(real_output_surface), surface_manager, GetSharedBitmapManager(),
- GetGpuMemoryBufferManager(), compositor->GetRendererSettings(),
- compositor->task_runner()));
- scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
- new cc::SurfaceDisplayOutputSurface(surface_manager,
- compositor->surface_id_allocator(),
- context_provider, nullptr));
- display_client_->set_surface_output_surface(surface_output_surface.get());
- surface_output_surface->set_display_client(display_client_.get());
- display_client_->display()->Resize(compositor->size());
- compositor->SetOutputSurface(std::move(surface_output_surface));
-}
-
-scoped_ptr<ui::Reflector> ContextFactoryEfl::CreateReflector(
+ display_ = base::MakeUnique<cc::Display>(
+ surface_manager, GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
+ compositor->GetRendererSettings(),
+ compositor->surface_id_allocator()->id_namespace(),
+ std::move(begin_frame_source), std::move(display_output_surface),
+ std::move(scheduler), base::MakeUnique<cc::TextureMailboxDeleter>(
+ compositor->task_runner().get()));
+
+ std::unique_ptr<cc::SurfaceDisplayOutputSurface> delegated_output_surface(
+ new cc::SurfaceDisplayOutputSurface(
+ surface_manager, compositor->surface_id_allocator(), display_.get(),
+ context_provider, nullptr));
+
+ display_->Resize(compositor->size());
+ compositor->SetOutputSurface(std::move(delegated_output_surface));
+}
+
+std::unique_ptr<ui::Reflector> ContextFactoryEfl::CreateReflector(
ui::Compositor* mirrored_compositor,
ui::Layer* mirroring_layer) {
- return make_scoped_ptr(new FakeReflector);
+ return base::WrapUnique(new FakeReflector);
}
void ContextFactoryEfl::RemoveReflector(ui::Reflector* reflector) {}
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<gpu::GpuChannelHost> gpu_channel_host(
- factory->EstablishGpuChannelSync(cause));
+ BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(
+ CAUSE_FOR_GPU_LAUNCH_BROWSER_SHARED_MAIN_THREAD_CONTEXT));
if (gpu_channel_host.get() && !gpu_channel_host->IsLost()) {
- shared_main_thread_contexts_ =
- content::ContextProviderCommandBuffer::Create(
- CreateGpuProcessViewContext(gpu_channel_host, attrs, 0),
- content::BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
+ GURL url("chrome://gpu/Compositor::createContext3D");
+ constexpr bool automatic_flushes = false;
+ constexpr bool support_locking = false;
+ constexpr gl::GpuPreference gpu_preference = gl::PreferIntegratedGpu;
+ shared_main_thread_contexts_ = new content::ContextProviderCommandBuffer(
+ std::move(gpu_channel_host), gpu::GPU_STREAM_DEFAULT,
+ gpu::GpuStreamPriority::NORMAL, gpu::kNullSurfaceHandle, url,
+ gpu_preference, automatic_flushes, support_locking,
+ gpu::SharedMemoryLimits(), attrs, NULL,
+ command_buffer_metrics::BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
}
if (!shared_main_thread_contexts_->BindToCurrentThread())
return task_graph_runner_.get();
}
-scoped_ptr<cc::SurfaceIdAllocator>
+std::unique_ptr<cc::SurfaceIdAllocator>
ContextFactoryEfl::CreateSurfaceIdAllocator() {
- scoped_ptr<cc::SurfaceIdAllocator> allocator =
- make_scoped_ptr(new cc::SurfaceIdAllocator(next_surface_id_namespace_++));
+ std::unique_ptr<cc::SurfaceIdAllocator> allocator = base::WrapUnique(
+ new cc::SurfaceIdAllocator(next_surface_id_namespace_++));
if (GetSurfaceManager())
allocator->RegisterSurfaceIdNamespace(GetSurfaceManager());
return allocator;
void ContextFactoryEfl::ResizeDisplay(ui::Compositor* compositor,
const gfx::Size& size) {
- if (display_client_)
- display_client_->display()->Resize(size);
+ if (display_)
+ display_->Resize(size);
}
ui::ContextFactory* ContextFactoryEfl::GetContextFactory() {
return surface_manager_.get();
}
-GLHelper* ContextFactoryEfl::GetGLHelper() {
+display_compositor::GLHelper* ContextFactoryEfl::GetGLHelper() {
if (!gl_helper_) {
scoped_refptr<cc::ContextProvider> provider =
SharedMainThreadContextProvider();
if (provider.get())
- gl_helper_.reset(
- new GLHelper(provider->ContextGL(), provider->ContextSupport()));
+ gl_helper_.reset(new display_compositor::GLHelper(
+ provider->ContextGL(), provider->ContextSupport()));
}
return gl_helper_.get();
}
-void ContextFactoryEfl::AddObserver(ImageTransportFactoryObserver* observer) {
+void ContextFactoryEfl::AddObserver(ui::ContextFactoryObserver* observer) {
observer_list_.AddObserver(observer);
}
-void ContextFactoryEfl::RemoveObserver(
- ImageTransportFactoryObserver* observer) {
+void ContextFactoryEfl::RemoveObserver(ui::ContextFactoryObserver* observer) {
observer_list_.RemoveObserver(observer);
}
#ifndef CONTENT_BROWSER_COMPOSITOR_CONTEXT_FACTORY_EFL_H_
#define CONTENT_BROWSER_COMPOSITOR_CONTEXT_FACTORY_EFL_H_
+#include "cc/surfaces/display.h"
#include "content/browser/compositor/image_transport_factory.h"
#include "ui/compositor/compositor.h"
namespace cc {
-class OnscreenDisplayClient;
class SingleThreadTaskGraphRunner;
class SurfaceManager;
}
// ui::ContextFactory implementation.
void CreateOutputSurface(base::WeakPtr<ui::Compositor> compositor) override;
- scoped_ptr<ui::Reflector> CreateReflector(ui::Compositor* source,
- ui::Layer* target) override;
+ std::unique_ptr<ui::Reflector> CreateReflector(ui::Compositor* source,
+ ui::Layer* target) override;
void RemoveReflector(ui::Reflector* reflector) override;
void RemoveCompositor(ui::Compositor* compositor) override;
scoped_refptr<cc::ContextProvider> SharedMainThreadContextProvider() override;
cc::SharedBitmapManager* GetSharedBitmapManager() override;
gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
cc::TaskGraphRunner* GetTaskGraphRunner() override;
- scoped_ptr<cc::SurfaceIdAllocator> CreateSurfaceIdAllocator() override;
+ std::unique_ptr<cc::SurfaceIdAllocator> CreateSurfaceIdAllocator() override;
void ResizeDisplay(ui::Compositor* compositor,
const gfx::Size& size) override;
+ void SetAuthoritativeVSyncInterval(ui::Compositor* compositor,
+ base::TimeDelta interval) override {}
+
+ void SetOutputIsSecure(ui::Compositor* compositor, bool secure) override {}
// ImageTransportFactory implementation.
ui::ContextFactory* GetContextFactory() override;
cc::SurfaceManager* GetSurfaceManager() override;
- GLHelper* GetGLHelper() override;
- void AddObserver(ImageTransportFactoryObserver* observer) override;
- void RemoveObserver(ImageTransportFactoryObserver* observer) override;
+ display_compositor::GLHelper* GetGLHelper() override;
+ void AddObserver(ui::ContextFactoryObserver* observer) override;
+ void RemoveObserver(ui::ContextFactoryObserver* observer) override;
private:
- scoped_ptr<GLHelper> gl_helper_;
- base::ObserverList<ImageTransportFactoryObserver> observer_list_;
- scoped_ptr<cc::SurfaceManager> surface_manager_;
+ std::unique_ptr<display_compositor::GLHelper> gl_helper_;
+ base::ObserverList<ui::ContextFactoryObserver> observer_list_;
+ std::unique_ptr<cc::SurfaceManager> surface_manager_;
uint32_t next_surface_id_namespace_;
- scoped_ptr<cc::OnscreenDisplayClient> display_client_;
- scoped_ptr<cc::SingleThreadTaskGraphRunner> task_graph_runner_;
+ std::unique_ptr<cc::Display> display_;
+ std::unique_ptr<cc::SingleThreadTaskGraphRunner> task_graph_runner_;
scoped_refptr<ContextProviderCommandBuffer> shared_main_thread_contexts_;
DISALLOW_COPY_AND_ASSIGN(ContextFactoryEfl);
#include "content/browser/compositor/mailbox_output_surface_efl.h"
-#include "base/thread_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
#include "build/tizen_version.h"
#include "cc/output/output_surface_client.h"
#include "cc/raster/single_thread_task_graph_runner.h"
MailboxOutputSurfaceEfl::MailboxOutputSurfaceEfl(
const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
cc::ResourceFormat format)
- : cc::OutputSurface(context_provider),
+ : cc::OutputSurface(context_provider, nullptr, nullptr),
swap_buffers_completion_callback_(
base::Bind(&MailboxOutputSurfaceEfl::OnSwapBuffersCompleted,
base::Unretained(this))),
}
void MailboxOutputSurfaceEfl::DrawTexture(
- scoped_ptr<cc::GLFrameData> gl_frame_data) {
+ std::unique_ptr<cc::GLFrameData> gl_frame_data) {
// Draw texture on RWHV
if (gl_frame_data) {
compositor_client_->GetTextureFromMailbox(&gl_frame_data->mailbox,
}
void MailboxOutputSurfaceEfl::OnSwapAck(
- scoped_ptr<cc::GLFrameData> gl_frame_data) {
+ std::unique_ptr<cc::GLFrameData> gl_frame_data) {
// Ignore message if it's a stale one coming from a different output surface
// (e.g. after a lost context).
+
if (!gl_frame_data->mailbox.IsZero()) {
DCHECK(!gl_frame_data->size.IsEmpty());
// The browser could be returning the oldest or any other pending texture
client_->DidSwapBuffersComplete();
}
-void MailboxOutputSurfaceEfl::SwapBuffers(cc::CompositorFrame* frame) {
- DCHECK(frame->gl_frame_data);
+void MailboxOutputSurfaceEfl::SwapBuffers(cc::CompositorFrame frame) {
+ DCHECK(frame.gl_frame_data);
DCHECK(!surface_size_.IsEmpty());
DCHECK(surface_size_ == current_backing_.size);
- DCHECK(frame->gl_frame_data->size == current_backing_.size);
+ DCHECK(frame.gl_frame_data->size == current_backing_.size);
DCHECK(!current_backing_.mailbox.IsZero() ||
context_provider_->ContextGL()->GetGraphicsResetStatusKHR() !=
GL_NO_ERROR);
- frame->gl_frame_data->mailbox = current_backing_.mailbox;
+ frame.gl_frame_data->mailbox = current_backing_.mailbox;
// Using glFinish call instead of glFlush, fixes black screen issue with
// static pages and IE Fish page.
gpu::SyncToken sync_token;
gl->GenSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
- frame->gl_frame_data->sync_token = sync_token;
+ frame.gl_frame_data->sync_token = sync_token;
base::Closure closure =
base::Bind(&MailboxOutputSurfaceEfl::OnSwapAck, base::Unretained(this),
- base::Passed(&frame->gl_frame_data));
+ base::Passed(&frame.gl_frame_data));
context_provider()->ContextSupport()->SignalSyncToken(sync_token, closure);
current_backing_ = TransferableFrame();
}
+uint32_t MailboxOutputSurfaceEfl::GetFramebufferCopyTextureFormat() {
+ auto* gl =
+ static_cast<ContextProviderCommandBuffer*>(context_provider_.get());
+ return gl->GetCopyTextureInternalFormat();
+}
+
bool MailboxOutputSurfaceEfl::BindToClient(cc::OutputSurfaceClient* client) {
if (!OutputSurface::BindToClient(client))
return false;
void MailboxOutputSurfaceEfl::OnSwapBuffersCompleted(
const std::vector<ui::LatencyInfo>& latency_info,
- gfx::SwapResult result) {
+ gfx::SwapResult result,
+ const gpu::GpuProcessHostedCALayerTreeParamsMac* params_mac) {
RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
OutputSurface::OnSwapBuffersComplete();
}
void DiscardBackbuffer() override;
void Reshape(const gfx::Size& size, float scale_factor, bool alpha) override;
void BindFramebuffer() override;
- void SwapBuffers(cc::CompositorFrame* frame) override;
+ void SwapBuffers(cc::CompositorFrame frame) override;
void SetCompositorClient(ui::CompositorClient* client) {
compositor_client_ = client;
}
+ uint32_t GetFramebufferCopyTextureFormat() override;
+
private:
- void OnSwapAck(scoped_ptr<cc::GLFrameData> gl_frame_data);
- void DrawTexture(scoped_ptr<cc::GLFrameData> gl_frame_data);
+ void OnSwapAck(std::unique_ptr<cc::GLFrameData> gl_frame_data);
+ void DrawTexture(std::unique_ptr<cc::GLFrameData> gl_frame_data);
gpu::CommandBufferProxyImpl* GetCommandBufferProxy();
- void OnSwapBuffersCompleted(const std::vector<ui::LatencyInfo>& latency_info,
- gfx::SwapResult result);
+ void OnSwapBuffersCompleted(
+ const std::vector<ui::LatencyInfo>& latency_info,
+ gfx::SwapResult result,
+ const gpu::GpuProcessHostedCALayerTreeParamsMac* params_mac);
struct TransferableFrame {
TransferableFrame();
gfx::Size size;
};
- base::CancelableCallback<void(const std::vector<ui::LatencyInfo>&,
- gfx::SwapResult)>
+ base::CancelableCallback<void(
+ const std::vector<ui::LatencyInfo>&,
+ gfx::SwapResult,
+ const gpu::GpuProcessHostedCALayerTreeParamsMac* params_mac)>
swap_buffers_completion_callback_;
ui::CompositorClient* compositor_client_;
#include <sensor/sensor.h>
-#include "base/memory/scoped_ptr.h"
#include "base/synchronization/lock.h"
#include "content/browser/device_sensors/device_sensors_consts.h"
#include "content/common/device_sensors/device_motion_hardware_buffer.h"
#include "content/browser/renderer_host/web_event_factory_efl.h"
#include "content/common/paths_efl.h"
#include "ui/events/event.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/screen.h"
#if defined(OS_TIZEN_MOBILE)
#include <efl_extension.h>
int parent_view_x = 0, parent_view_y = 0;
evas_object_geometry_get(parent_view_, &parent_view_x, &parent_view_y, 0, 0);
- float device_scale_factor = gfx::Screen::GetScreen()->
+ float device_scale_factor = display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
event->canvas.x = target_rect_x + (parent_view_x * device_scale_factor);
event->canvas.y = target_rect_y + (parent_view_y * device_scale_factor);
#include "base/trace_event/trace_event.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/string_number_conversions.h"
-#include "base/thread_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
#include "base/logging.h"
#include "base/strings/utf_string_conversions.h"
-#include "content/browser/compositor/gl_helper.h"
+#include "components/display_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 "third_party/WebKit/public/web/WebTouchPoint.h"
#include "ui/base/clipboard/clipboard_helper_efl.h"
#include "ui/base/layout.h"
-#include "ui/base/touch/selection_bound.h"
#include "ui/events/blink/blink_event_util.h"
#include "ui/events/event_switches.h"
#include "ui/events/event_utils.h"
#undef private
#include "ui/events/gestures/gesture_recognizer_impl_efl.h"
#include "ui/compositor/compositor.h"
-#include "ui/gfx/device_display_info_efl.h"
-#include "ui/gfx/display.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
+#include "ui/display/device_display_info_efl.h"
#include "ui/gfx/geometry/dip_util.h"
#include "ui/gfx/geometry/rect.h"
-#include "ui/gfx/screen.h"
+#include "ui/gfx/selection_bound.h"
#include "ui/gl/gl_shared_context_efl.h"
#if defined(OS_TIZEN_MOBILE)
namespace {
-ui::SelectionBound::Type ConvertSelectionBoundType(
- cc::SelectionBoundType type) {
- switch (type) {
- case cc::SELECTION_BOUND_LEFT:
- return ui::SelectionBound::LEFT;
- case cc::SELECTION_BOUND_RIGHT:
- return ui::SelectionBound::RIGHT;
- case cc::SELECTION_BOUND_CENTER:
- return ui::SelectionBound::CENTER;
- case cc::SELECTION_BOUND_EMPTY:
- return ui::SelectionBound::EMPTY;
- }
- NOTREACHED() << "Unknown selection bound type";
- return ui::SelectionBound::EMPTY;
-}
-
-ui::SelectionBound ConvertSelectionBound(
- const cc::ViewportSelectionBound& bound) {
- ui::SelectionBound ui_bound;
- ui_bound.set_type(ConvertSelectionBoundType(bound.type));
- ui_bound.set_visible(bound.visible);
- if (ui_bound.type() != ui::SelectionBound::EMPTY)
- ui_bound.SetEdge(bound.edge_top, bound.edge_bottom);
- return ui_bound;
-}
-
bool IsShiftKey(const char * key) {
if (!key)
return false;
return !strcmp(key, "Shift_L") || !strcmp(key, "Shift_R");
}
+// Creates a WebGestureEvent from a ui::GestureEvent. Note that it does not
+// populate the event coordinates (i.e. |x|, |y|, |globalX|, and |globalY|). So
+// the caller must populate these fields.
+blink::WebGestureEvent MakeWebGestureEventFromUIEvent(
+ const ui::GestureEvent& event) {
+ return ui::CreateWebGestureEvent(
+ event.details(), event.time_stamp(), event.location_f(),
+ event.root_location_f(), event.flags(), event.unique_touch_event_id());
+}
+
} // namespace
class ScreenshotCapturedCallback {
void RenderWidgetHostViewBase::GetDefaultScreenInfo(
blink::WebScreenInfo* results) {
- const gfx::Display display = gfx::Screen::GetScreen()->GetPrimaryDisplay();
+ const display::Display display = display::Screen::GetScreen()->GetPrimaryDisplay();
results->rect = display.bounds();
results->availableRect = display.work_area();
SetDoubleTapSupportEnabled(touch_events_enabled_);
- device_scale_factor_ = gfx::Screen::GetScreen()->
+ device_scale_factor_ = display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
host_->SetView(this);
api->glGetProgramiv(program, GL_LINK_STATUS, &status);
if (!status) {
const GLsizei buf_length = 2048;
- scoped_ptr<GLchar[]> log(new GLchar[buf_length]);
+ std::unique_ptr<GLchar[]> log(new GLchar[buf_length]);
GLsizei length = 0;
api->glGetProgramInfoLog(program, buf_length, &length, log.get());
LOG(ERROR) << "GL program link failed in: " << file << ":" << line
api->glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (!status) {
const GLsizei buf_length = 2048;
- scoped_ptr<GLchar[]> log(new GLchar[buf_length]);
+ std::unique_ptr<GLchar[]> log(new GLchar[buf_length]);
GLsizei length = 0;
api->glGetShaderInfoLog(shader, buf_length, &length, log.get());
LOG(ERROR) << "GL shader compile failed in " << file << ":" << line
}
void RenderWidgetHostViewEfl::UpdateRotationDegrees(int rotation_degrees) {
- gfx::DeviceDisplayInfoEfl display_info;
+ display::DeviceDisplayInfoEfl display_info;
display_info.SetRotationDegrees(rotation_degrees);
Send(new ViewMsg_UpdateRotationDegrees(host_->GetRoutingID(),
display_info.GetRotationDegrees()));
initialized = true;
- gfx::DeviceDisplayInfoEfl display_info;
+ display::DeviceDisplayInfoEfl display_info;
int display_width = 0;
int display_height = 0;
int view_x, view_y;
EvasToBlinkCords(touch_point.x(), touch_point.y(), &view_x, &view_y);
+#if !defined(EWK_BRINGUP)
+// [M53_2785] The SelectClosestWord function was removed by
+// commit 9720a4494c8bcd24d1f496feec5cfac7582103d2 in s-chromium
+// It will be fixed by webview team.
+// FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2122
Send(new ViewMsg_SelectClosestWord(
host_->GetRoutingID(), view_x, view_y));
+#endif // EWK_BRINGUP
}
void RenderWidgetHostViewEfl::ShowDisambiguationPopup(const gfx::Rect& rect_pixels, const SkBitmap& zoomed_bitmap) {
return this == consumer;
}
-void RenderWidgetHostViewEfl::DispatchCancelTouchEvent(
- ui::GestureConsumer* raw_input_consumer,
- ui::TouchEvent* event) {}
+void RenderWidgetHostViewEfl::DispatchSyntheticTouchEvent(ui::TouchEvent* event) {
+}
void RenderWidgetHostViewEfl::DispatchGestureEvent(
GestureConsumer* raw_input_consumer,
void RenderWidgetHostViewEfl::CopyOutputCallback(
int request_id,
- scoped_ptr<cc::CopyOutputResult> result) {
+ std::unique_ptr<cc::CopyOutputResult> result) {
if (!result->HasBitmap())
return;
- scoped_ptr<SkBitmap> snapshot = std::move(result->TakeBitmap());
+ std::unique_ptr<SkBitmap> snapshot = std::move(result->TakeBitmap());
Evas_Object* image = NULL;
if (!snapshot.get()->empty()) {
if (!compositor_)
return;
- scoped_ptr<cc::CopyOutputRequest> request = cc::CopyOutputRequest::CreateBitmapRequest(
+ std::unique_ptr<cc::CopyOutputRequest> request = cc::CopyOutputRequest::CreateBitmapRequest(
base::Bind(&RenderWidgetHostViewEfl::CopyOutputCallback, weak_factory_.GetWeakPtr(), request_id));
request->set_area(snapshot_area);
compositor_->root_layer()->RequestCopyOfOutput(std::move(request));
}
void RenderWidgetHostViewEfl::BeginFrameSubscription(
- scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
+ std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
delegated_frame_host_->BeginFrameSubscription(std::move(subscriber));
}
base::WeakPtr<RenderWidgetHostViewEfl> rwhvefl,
const base::Callback<void(bool)>& callback,
scoped_refptr<OwnedMailbox> subscriber_texture,
- scoped_ptr<cc::SingleReleaseCallback> release_callback,
+ std::unique_ptr<cc::SingleReleaseCallback> release_callback,
bool result) {
callback.Run(result);
- GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
+ display_compositor::GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
gpu::SyncToken sync_token;
if (gl_helper)
gl_helper->GenerateSyncToken(&sync_token);
scoped_refptr<OwnedMailbox> subscriber_texture,
scoped_refptr<media::VideoFrame> video_frame,
const base::Callback<void(const gfx::Rect&, bool)>& callback,
- scoped_ptr<cc::CopyOutputResult> result) {
+ std::unique_ptr<cc::CopyOutputResult> result) {
base::ScopedClosureRunner scoped_callback_runner(
base::Bind(callback, gfx::Rect(), false));
base::ScopedClosureRunner scoped_return_subscriber_texture(
if (!result->HasTexture()) {
DCHECK(result->HasBitmap());
- scoped_ptr<SkBitmap> bitmap = result->TakeBitmap();
+ std::unique_ptr<SkBitmap> bitmap = result->TakeBitmap();
// Scale the bitmap to the required size, if necessary.
SkBitmap scaled_bitmap;
if (result->size().width() != region_in_frame.width() ||
}
ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
- GLHelper* gl_helper = factory->GetGLHelper();
+ display_compositor::GLHelper* gl_helper = factory->GetGLHelper();
if (!gl_helper)
return;
if (subscriber_texture.get() && !subscriber_texture->texture_id())
return;
cc::TextureMailbox texture_mailbox;
- scoped_ptr<cc::SingleReleaseCallback> release_callback;
+ std::unique_ptr<cc::SingleReleaseCallback> release_callback;
result->TakeTexture(&texture_mailbox, &release_callback);
DCHECK(texture_mailbox.IsTexture());
if (!texture_mailbox.IsTexture())
gfx::Rect result_rect(result->size());
- content::ReadbackYUVInterface* yuv_readback_pipeline =
+ display_compositor::ReadbackYUVInterface* yuv_readback_pipeline =
rwhvefl->yuv_readback_pipeline_.get();
if (yuv_readback_pipeline == NULL ||
yuv_readback_pipeline->scaler()->SrcSize() != result_rect.size() ||
yuv_readback_pipeline->scaler()->SrcSubrect() != result_rect ||
yuv_readback_pipeline->scaler()->DstSize() != region_in_frame.size()) {
- GLHelper::ScalerQuality quality = GLHelper::SCALER_QUALITY_FAST;
+ display_compositor::GLHelper::ScalerQuality quality = display_compositor::GLHelper::SCALER_QUALITY_FAST;
// 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 = GLHelper::SCALER_QUALITY_BEST;
+ quality = display_compositor::GLHelper::SCALER_QUALITY_BEST;
rwhvefl->yuv_readback_pipeline_.reset(
gl_helper->CreateReadbackPipelineYUV(quality,
subscriber_texture,
base::Passed(&release_callback));
yuv_readback_pipeline->ReadbackYUV(
- texture_mailbox.mailbox(),
- texture_mailbox.sync_token(),
- video_frame,
- video_frame->visible_rect().origin(),
+ texture_mailbox.mailbox(), texture_mailbox.sync_token(),
+ video_frame->visible_rect(),
+ video_frame->stride(media::VideoFrame::kYPlane),
+ video_frame->data(media::VideoFrame::kYPlane),
+ video_frame->stride(media::VideoFrame::kUPlane),
+ video_frame->data(media::VideoFrame::kUPlane),
+ video_frame->stride(media::VideoFrame::kVPlane),
+ video_frame->data(media::VideoFrame::kVPlane), region_in_frame.origin(),
finished_callback);
}
RenderWidgetHostViewBase::GetDefaultScreenInfo(results);
}
-bool RenderWidgetHostViewEfl::GetScreenColorProfile(std::vector<char>* color_profile) {
- DCHECK(color_profile->empty());
- NOTREACHED();
- return false;
-}
-
gfx::Rect RenderWidgetHostViewEfl::GetBoundsInRootWindow() {
Ecore_Evas* ee = ecore_evas_ecore_evas_get(evas_);
int x, y, w, h;
void RenderWidgetHostViewEfl::HandleGesture(ui::GestureEvent* event) {
blink::WebGestureEvent gesture =
- content::MakeWebGestureEventFromUIEvent(*event);
+ MakeWebGestureEventFromUIEvent(*event);
gesture.x = event->x();
gesture.y = event->y();
ui::EventResult result = (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED) ?
ui::ER_HANDLED : ui::ER_UNHANDLED;
- scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
+ std::unique_ptr<ui::GestureRecognizer::Gestures> gestures;
gestures.reset(gesture_recognizer_->AckTouchEvent(
touch.event.uniqueTouchEventId, result, this));
EdgeEffect& RenderWidgetHostViewEfl::EnsureEdgeEffect() {
if (!edge_effect_)
- edge_effect_ = make_scoped_ptr(new EdgeEffect(content_image_elm_host_));
+ edge_effect_ = base::WrapUnique(new EdgeEffect(content_image_elm_host_));
return *edge_effect_.get();
}
}
void RenderWidgetHostViewEfl::OnSwapCompositorFrame(
- uint32_t output_surface_id, scoped_ptr<cc::CompositorFrame> frame) {
- // TODO(prashant.n): Software frames not supported. So with
- // those frames black screen will appear.
- last_scroll_offset_ = frame->metadata.root_scroll_offset;
+ uint32_t output_surface_id, cc::CompositorFrame frame) {
+ last_scroll_offset_ = frame.metadata.root_scroll_offset;
if (GetSelectionController()) {
GetSelectionController()->SetSelectionEditable(
- frame->metadata.selection.is_editable);
+ frame.metadata.selection.is_editable);
GetSelectionController()->SetSelectionEmpty(
- frame->metadata.selection.is_empty_text_form_control);
- ui::SelectionBound start = ConvertSelectionBound(frame->metadata.selection.start);
- ui::SelectionBound end = ConvertSelectionBound(frame->metadata.selection.end);
- GetSelectionController()->OnSelectionChanged(start, end);
- }
+ frame.metadata.selection.is_empty_text_form_control);
- if (frame->gl_frame_data) {
- cc::CompositorFrameAck ack;
- ack.gl_frame_data = std::move(frame->gl_frame_data);
- surface_size_ = ack.gl_frame_data->size;
- if (evas_gl_initialized_) {
- std::swap(ack.gl_frame_data->mailbox, pending_mailbox_);
- gpu::gles2::MailboxManager* manager =
- SharedMailboxManager::GetMailboxManager();
-
- gpu::gles2::Texture* texture =
- manager->ConsumeTexture(pending_mailbox_);
- if (texture != NULL) {
- texture_id_ = GetTextureIdFromTexture(texture);
- evas_object_image_pixels_dirty_set(content_image_, true);
- } else {
- LOG(ERROR) << "Frame produced without texture.";
- }
- }
-
- ack.gl_frame_data->sync_token.Clear();
-
- // TODO(prashant.n): Check if ack should be sent after frame is drawn.
- host_->SendSwapCompositorFrameAck(host_->GetRoutingID(),
- output_surface_id,
- host_->GetProcess()->GetID(),
- ack);
+ GetSelectionController()->OnSelectionChanged(
+ frame.metadata.selection.start, frame.metadata.selection.end);
+ }
- } else if (frame->delegated_frame_data) {
+ if (frame.delegated_frame_data) {
// ack is sent by delegated frame host
delegated_frame_host_->SwapDelegatedFrame(output_surface_id,
std::move(frame));
} else {
- NOTREACHED();
+ LOG(ERROR) << "Non-delegated renderer path (software or gl) is no longer "
+ << "supported. With this black screen will occur.";
}
-
}
void RenderWidgetHostViewEfl::ClearCompositorFrame () {
///////////////////////////////////////////////////////////////////////////
// DelegatedFrameHost, public:
+int RenderWidgetHostViewEfl::DelegatedFrameHostGetGpuMemoryBufferClientId() const {
+ return host_->GetProcess()->GetID();
+}
+
ui::Layer* RenderWidgetHostViewEfl::DelegatedFrameHostGetLayer() const {
return root_layer_.get();
}
return !host_->is_hidden();
}
+SkColor RenderWidgetHostViewEfl::DelegatedFrameHostGetGutterColor(SkColor color) const {
+ // When making an element on the page fullscreen the element's background
+ // may not match the page's, so use black as the gutter color to avoid
+ // flashes of brighter colors during the transition.
+ if (host_->delegate() && host_->delegate()->IsFullscreenForCurrentTab())
+ return SK_ColorBLACK;
+ return color;
+}
+
gfx::Size RenderWidgetHostViewEfl::DelegatedFrameHostDesiredSizeInDIP() const{
gfx::Rect bounds = GetViewBoundsInPix();
return bounds.size();
return false;
}
-scoped_ptr<ResizeLock>
+std::unique_ptr<ResizeLock>
RenderWidgetHostViewEfl::DelegatedFrameHostCreateResizeLock(
bool defer_compositor_lock) {
ResizeLock* lock = NULL;
- return scoped_ptr<ResizeLock>(lock);
+ return std::unique_ptr<ResizeLock>(lock);
}
void RenderWidgetHostViewEfl::DelegatedFrameHostResizeLockWasReleased() {
const base::TimeDelta& interval) {
host_->UpdateVSyncParameters(timebase, interval);
}
+
+void RenderWidgetHostViewEfl::SetBeginFrameSource(cc::BeginFrameSource* source) {
+}
} // namespace content
class IMContextEfl;
class RenderWidgetHostImpl;
class RenderWidgetHostView;
-class ReadbackYUVInterface;
class WebContents;
class ScreenshotCapturedCallback;
void SetBounds(const gfx::Rect&) override;
gfx::Vector2dF GetLastScrollOffset() const override;
gfx::NativeView GetNativeView() const override;
- gfx::NativeViewId GetNativeViewId() const override;
gfx::NativeViewAccessible GetNativeViewAccessible() override;
bool IsSurfaceAvailableForCopy() const override;
void Show() override;
bool CanCopyToVideoFrame() const override;
void BeginFrameSubscription(
- scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) override;
+ std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) override;
void EndFrameSubscription() override;
void DidOverscroll(const DidOverscrollParams& params) override;
bool HasAcceleratedSurface(const gfx::Size&) override;
void GetScreenInfo(blink::WebScreenInfo*) override;
- bool GetScreenColorProfile(std::vector<char>* color_profile) override;
gfx::Rect GetBoundsInRootWindow() override;
void RenderProcessGone(base::TerminationStatus, int) override;
bool OnMessageReceived(const IPC::Message&) override;
void UnlockCompositingSurface() override;
void OnSwapCompositorFrame(
- uint32_t output_surface_id, scoped_ptr<cc::CompositorFrame> frame) override;
+ uint32_t output_surface_id, cc::CompositorFrame frame) override;
void ClearCompositorFrame () override;
// ui::GestureEventHelper implementation.
bool CanDispatchToConsumer(ui::GestureConsumer* consumer) override;
- void DispatchCancelTouchEvent(ui::GestureConsumer* raw_input_consumer,
- ui::TouchEvent* event) override;
+ void DispatchSyntheticTouchEvent(ui::TouchEvent* event) override;
void DispatchGestureEvent(GestureConsumer* raw_input_consumer,
ui::GestureEvent*) override;
void* user_data);
void OnSnapshotDataReceived(SkBitmap bitmap, int snapshotId);
void CopyOutputCallback(int request_id,
- scoped_ptr<cc::CopyOutputResult> result);
+ std::unique_ptr<cc::CopyOutputResult> result);
// DelegatedFrameHostClient implementation.
+ int DelegatedFrameHostGetGpuMemoryBufferClientId() const override;
ui::Layer* DelegatedFrameHostGetLayer() const override;
bool DelegatedFrameHostIsVisible() const override;
- scoped_ptr<ResizeLock> DelegatedFrameHostCreateResizeLock(
+ SkColor DelegatedFrameHostGetGutterColor(SkColor color) const override;
+ std::unique_ptr<ResizeLock> DelegatedFrameHostCreateResizeLock(
bool defer_compositor_lock) override;
bool DelegatedFrameCanCreateResizeLock() const override;
gfx::Size DelegatedFrameHostDesiredSizeInDIP() const override;
void DelegatedFrameHostUpdateVSyncParameters(
const base::TimeTicks& timebase,
const base::TimeDelta& interval) override;
+ void SetBeginFrameSource(cc::BeginFrameSource* source) override;
bool MakeCurrent();
SelectionControllerEfl* GetSelectionController() const {
~RenderWidgetHostViewEfl() override;
void EnsureDeviceDisplayInfoInitialized();
+ gfx::NativeViewId GetNativeViewId() const;
static void OnParentViewResize(void* data, Evas*, Evas_Object*, void*);
static void OnFocusIn(void* data, Evas*, Evas_Object*, void*);
scoped_refptr<OwnedMailbox> subscriber_texture,
scoped_refptr<media::VideoFrame> video_frame,
const base::Callback<void(const gfx::Rect&, bool)>& callback,
- scoped_ptr<cc::CopyOutputResult> result);
+ std::unique_ptr<cc::CopyOutputResult> result);
static void CopyFromCompositingSurfaceFinishedForVideo(
base::WeakPtr<RenderWidgetHostViewEfl> rwhvefl,
const base::Callback<void(bool)>& callback,
scoped_refptr<OwnedMailbox> subscriber_texture,
- scoped_ptr<cc::SingleReleaseCallback> release_callback,
+ std::unique_ptr<cc::SingleReleaseCallback> release_callback,
bool result);
static void ReturnSubscriberTexture(
base::WeakPtr<RenderWidgetHostViewEfl> rwhvefl,
scoped_refptr<EvasEventHandler> evas_event_handler_;
// YUV readback pipeline.
- scoped_ptr<content::ReadbackYUVInterface>
+ std::unique_ptr<display_compositor::ReadbackYUVInterface>
yuv_readback_pipeline_;
// Subscriber that listens to frame presentation events.
- scoped_ptr<RenderWidgetHostViewFrameSubscriber> frame_subscriber_;
+ std::unique_ptr<RenderWidgetHostViewFrameSubscriber> frame_subscriber_;
std::vector<scoped_refptr<OwnedMailbox> > idle_frame_subscriber_textures_;
std::set<OwnedMailbox*> active_frame_subscriber_textures_;
// The gesture recognizer for this view.
// In Aura GestureRecognizer is global. Should we follow that?
- scoped_ptr<ui::GestureRecognizer> gesture_recognizer_;
+ std::unique_ptr<ui::GestureRecognizer> gesture_recognizer_;
- scoped_ptr<DisambiguationPopupEfl> disambiguation_popup_;
- scoped_ptr<EdgeEffect> edge_effect_;
+ std::unique_ptr<DisambiguationPopupEfl> disambiguation_popup_;
+ std::unique_ptr<EdgeEffect> edge_effect_;
int current_orientation_;
IDMap<ScreenshotCapturedCallback, IDMapOwnPointer> screen_capture_cb_map_;
ui::Compositor* compositor_;
- scoped_ptr<ui::Layer> root_layer_;
- scoped_ptr<DelegatedFrameHost> delegated_frame_host_;
+ std::unique_ptr<ui::Layer> root_layer_;
+ std::unique_ptr<DelegatedFrameHost> delegated_frame_host_;
- scoped_ptr<SelectionControllerEfl> selection_controller_;
+ std::unique_ptr<SelectionControllerEfl> selection_controller_;
base::WeakPtrFactory<RenderWidgetHostViewEfl> weak_factory_;
#include "base/time/time.h"
#include "base/strings/utf_string_conversions.h"
+#include "ui/display/screen.h"
#include "ui/events/event_utils.h"
#include "ui/events/keycodes/keyboard_codes.h"
#include "ui/events/keycodes/keyboard_code_conversion_x.h"
-#include "ui/gfx/screen.h"
using namespace blink;
float GetDeviceScaleFactor() {
static float device_scale_factor = 0.0f;
if (!device_scale_factor) {
- device_scale_factor = gfx::Screen::GetScreen()->
+ device_scale_factor = display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
}
return device_scale_factor;
unsigned int timestamp) {
TranslateEvasCoordToWebKitCoord(view, pt.x, pt.y);
const float scale = GetDeviceScaleFactor();
- base::TimeDelta event_timestamp =
- base::TimeDelta::FromMilliseconds(timestamp);
+ base::TimeTicks event_timestamp =
+ base::TimeTicks::FromInternalValue(
+ timestamp * base::Time::kMicrosecondsPerMillisecond);
+
if (timestamp == 0)
event_timestamp = ui::EventTimeForNow();
return ui::TouchEvent(EvasTouchEventTypeToUI(state),
#include <Evas.h>
-#include "base/memory/scoped_ptr.h"
#include "content/public/common/context_menu_params.h"
#include "content/public/common/menu_item.h"
#include "ui/gfx/range/range.h"
bool is_anchor_first_;
// Contains the menu item data for which context needs to be populated
- scoped_ptr<ContextMenuParams> context_params_;
+ std::unique_ptr<ContextMenuParams> context_params_;
Evas_Object* parent_view_;
};
#include "content/public/browser/web_contents.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/common/context_menu_params.h"
+#include "ui/display/screen.h"
#include "ui/gfx/geometry/dip_util.h"
-#include "ui/gfx/screen.h"
namespace content {
return rect == gfx::Rect();
}
-gfx::Vector2dF ComputeLineOffsetFromBottom(const ui::SelectionBound& bound) {
+gfx::Vector2dF ComputeLineOffsetFromBottom(const gfx::SelectionBound& bound) {
gfx::Vector2dF line_offset =
gfx::ScaleVector2d(bound.edge_top() - bound.edge_bottom(), 0.5f);
// An offset of 8 DIPs is sufficient for most line sizes. For small lines,
}
void SelectionControllerEfl::OnSelectionChanged(
- const ui::SelectionBound& start, const ui::SelectionBound& end) {
+ const gfx::SelectionBound& start, const gfx::SelectionBound& end) {
if (start_selection_ == start && end_selection_ == end)
return;
gfx::Rect truncated_end(end.edge_top_rounded(), gfx::Size(0, end.GetHeight()));
static float device_scale_factor =
- gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
+ display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
truncated_start = ConvertRectToPixel(device_scale_factor, truncated_start);
truncated_end = ConvertRectToPixel(device_scale_factor, truncated_end);
}
float device_scale_factor =
- gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
+ display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
gfx::PointF base = gfx::ScalePoint(
gfx::PointF(stationary_handle_->GetBasePosition()), 1 / device_scale_factor);
gfx::PointF extent = gfx::ScalePoint(
case SelectionHandleEfl::HANDLE_TYPE_LEFT:
case SelectionHandleEfl::HANDLE_TYPE_RIGHT: {
float device_scale_factor =
- gfx::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
+ display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor();
gfx::PointF extent = gfx::ScalePoint(
gfx::PointF(handle->GetBasePosition()), 1 / device_scale_factor);
#include <map>
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string16.h"
#include "content/browser/selection/selection_box_efl.h"
#include "content/browser/selection/selection_handle_efl.h"
#include "content/browser/selection/selection_magnifier_efl.h"
#include "content/common/content_export.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
-#include "ui/base/touch/selection_bound.h"
#include "ui/events/event_constants.h"
#include "ui/gfx/range/range.h"
+#include "ui/gfx/selection_bound.h"
#include "ui/gfx/geometry/rect.h"
#if defined(OS_TIZEN)
gfx::Rect GetLeftRect();
gfx::Rect GetRightRect();
- void OnSelectionChanged(const ui::SelectionBound&, const ui::SelectionBound&);
+ void OnSelectionChanged(const gfx::SelectionBound&, const gfx::SelectionBound&);
void OnTextInputStateChanged();
void ChangeContextMenuPosition(gfx::Point& position, int& drawDirection);
bool long_mouse_press_;
// Saves the data that are required to draw handle and context menu
- scoped_ptr<SelectionBoxEfl> selection_data_;
+ std::unique_ptr<SelectionBoxEfl> selection_data_;
// Points to start of the selection for extending selection
- scoped_ptr<SelectionHandleEfl> start_handle_;
+ std::unique_ptr<SelectionHandleEfl> start_handle_;
// Points to the end of the selection for extending selection
- scoped_ptr<SelectionHandleEfl> end_handle_;
+ std::unique_ptr<SelectionHandleEfl> end_handle_;
// Points to the caret in edit box where cursor is present
- scoped_ptr<SelectionHandleEfl> input_handle_;
+ std::unique_ptr<SelectionHandleEfl> input_handle_;
// Points to show the contents magnified
- scoped_ptr<SelectionMagnifierEfl> magnifier_;
+ std::unique_ptr<SelectionMagnifierEfl> magnifier_;
// Helper pointer to the handle being dragged.
SelectionHandleEfl* dragging_handle_;
WebContents& web_contents_;
enum SelectionMode selection_mode_;
- ui::SelectionBound start_selection_;
- ui::SelectionBound end_selection_;
+ gfx::SelectionBound start_selection_;
+ gfx::SelectionBound end_selection_;
};
} // namespace content
#ifndef BROWSER_SPEECH_TTS_MESSAGE_FILTER_H_
#define BROWSER_SPEECH_TTS_MESSAGE_FILTER_H_
-#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "content/browser/speech/tts_tizen.h"
#include "content/common/content_export.h"
void OnResume();
void OnCancel();
- scoped_ptr<TtsTizen> tts_tizen_;
+ std::unique_ptr<TtsTizen> tts_tizen_;
DISALLOW_COPY_AND_ASSIGN(TtsMessageFilterEfl);
};
// Save the created window associated with the route so we can show it
// later.
DCHECK_NE(MSG_ROUTING_NONE, route_id);
- pending_contents_[route_id] = new_contents;
+ pending_contents_[std::make_pair(render_process_id, route_id)] = new_contents;
AddDestructionObserver(new_contents);
}
void* platform_data_;
- scoped_ptr<WebContentsEflDelegate> efl_delegate_;
+ std::unique_ptr<WebContentsEflDelegate> efl_delegate_;
DISALLOW_COPY_AND_ASSIGN(WebContentsImplEfl);
};
#include "content/public/browser/web_contents_view_delegate.h"
#include "content/public/browser/web_contents_view_efl_delegate.h"
#include "efl/window_factory.h"
+#include "ui/display/screen_efl.h"
#include "ui/events/event_switches.h"
#include "ui/gfx/image/image_skia.h"
-#include "ui/gfx/screen_efl.h"
#include "ui/gl/gl_shared_context_efl.h"
namespace content {
WebContentsImpl& contents_impl =
static_cast<WebContentsImpl&>(*web_contents_);
- RenderViewHostImpl* rvhi =
- static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost());
ResizeParams params;
params.screen_info = screen_info;
params.new_size = new_size;
params.physical_backing_size = backing_size;
params.is_fullscreen_granted =
- contents_impl.IsFullscreenForCurrentTab(rvhi->GetWidget());
+ contents_impl.IsFullscreenForCurrentTab();
rwh->Send(new ViewMsg_Resize(rwh->GetRoutingID(), params));
rwhv->UpdateScreenInfo(rwhv->GetNativeView());
#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"
private:
// Our optional, generic views wrapper.
- scoped_ptr<WebContentsViewDelegate> delegate_;
+ std::unique_ptr<WebContentsViewDelegate> delegate_;
// Delegate specific to EFL port of chromium.
// May be NULL in case of non EWK apps.
- scoped_ptr<WebContentsViewEflDelegate> efl_delegate_;
+ std::unique_ptr<WebContentsViewEflDelegate> efl_delegate_;
Evas_Object* native_view_;
WebDragDestDelegate* drag_dest_delegate_;
// Helpers handling drag source/destination related interactions with EFL.
- scoped_ptr<WebDragSourceEfl> drag_source_;
- scoped_ptr<WebDragDestEfl> drag_dest_;
+ std::unique_ptr<WebDragSourceEfl> drag_source_;
+ std::unique_ptr<WebDragDestEfl> drag_dest_;
int orientation_;
bool touch_enabled_;
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/public/browser/web_drag_dest_delegate.h"
#include "content/public/browser/render_view_host.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/screen.h"
using blink::WebDragOperation;
parent_view_(static_cast<Evas_Object*>(web_contents->GetNativeView())),
page_scale_factor_(1.0f),
drag_initialized_(false) {
- device_scale_factor_ = gfx::Screen::GetScreen()->
+ device_scale_factor_ = display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
SetDragCallbacks();
}
gfx::Point(last_pointer_pos_.x() / page_scale_factor_,
last_pointer_pos_.y() / page_scale_factor_);
+ GetRenderViewHost()->FilterDropData(drop_data_.get());
GetRenderViewHost()->DragTargetDrop(
+ *drop_data_,
client_pt,
last_pointer_pos_,
modifier_flags_);
#include <Elementary.h>
-#include "base/memory/scoped_ptr.h"
#include "content/public/common/drop_data.h"
-#include "third_party/WebKit/public/web/WebDragOperation.h"
+#include "third_party/WebKit/public/platform/WebDragOperation.h"
#include "ui/gfx/geometry/point.h"
namespace content {
bool drag_initialized_;
// The data for the current drag, or NULL if |context_| is NULL.
- scoped_ptr<DropData> drop_data_;
+ std::unique_ptr<DropData> drop_data_;
DISALLOW_COPY_AND_ASSIGN(WebDragDestEfl);
};
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/public/common/drop_data.h"
#include "third_party/skia/include/core/SkPixelRef.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/screen.h"
namespace content {
drag_failed_(false),
drag_started_(false),
page_scale_factor_(1.0f) {
- device_scale_factor_ = gfx::Screen::GetScreen()->
+ device_scale_factor_ = display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
}
#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"
+#include "third_party/WebKit/public/platform/WebDragOperation.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/vector2d.h"
#include "url/gurl.h"
// The drop data for the current drag (for drags that originate in the render
// view). Non-NULL iff there is a current drag.
- scoped_ptr<DropData> drop_data_;
+ std::unique_ptr<DropData> drop_data_;
// The image used for depicting the drag, and the offset between the cursor
// and the top left pixel.
#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"
}
bool GetDirChromiumPrivateTizen(base::FilePath& result) {
- scoped_ptr<char, base::FreeDeleter> data_path(app_get_data_path());
+ std::unique_ptr<char, base::FreeDeleter> data_path(app_get_data_path());
if (data_path) {
result = base::FilePath(data_path.get());
} else if (!GetDirAppDataTizen(result)) {
#if defined(OS_TIZEN)
result = GetDirUserDataTizen();
if (result.empty()) {
- scoped_ptr<base::Environment> env(base::Environment::Create());
+ std::unique_ptr<base::Environment> env(base::Environment::Create());
base::FilePath config_dir(base::nix::GetXDGDirectory(env.get(),
base::nix::kXdgConfigHomeEnvVar,
base::nix::kDotConfigDir));
char* app_id = NULL;
if (APP_ERROR_NONE == app_get_id(&app_id)) {
- scoped_ptr<char, base::FreeDeleter> app_name(app_id);
+ std::unique_ptr<char, base::FreeDeleter> app_name(app_id);
result = config_dir.Append(app_name.get());
} else {
result = config_dir.Append(kApplicationName);
}
}
#else
- scoped_ptr<base::Environment> env(base::Environment::Create());
+ std::unique_ptr<base::Environment> env(base::Environment::Create());
base::FilePath config_dir(base::nix::GetXDGDirectory(env.get(),
base::nix::kXdgConfigHomeEnvVar,
base::nix::kDotConfigDir));
#if defined(OS_TIZEN)
result = GetDirCacheTizen();
if (result.empty()) {
- scoped_ptr<base::Environment> env(base::Environment::Create());
+ std::unique_ptr<base::Environment> env(base::Environment::Create());
base::FilePath cache_dir(base::nix::GetXDGDirectory(env.get(),
"XDG_CACHE_HOME",
".cache"));
char* app_id = NULL;
if (APP_ERROR_NONE == app_get_id(&app_id)) {
- scoped_ptr<char, base::FreeDeleter> app_name(app_id);
+ std::unique_ptr<char, base::FreeDeleter> app_name(app_id);
result = cache_dir.Append(app_name.get());
} else {
result = cache_dir.Append(kApplicationName);
}
}
#else
- scoped_ptr<base::Environment> env(base::Environment::Create());
+ std::unique_ptr<base::Environment> env(base::Environment::Create());
base::FilePath cache_dir(base::nix::GetXDGDirectory(env.get(),
"XDG_CACHE_HOME",
".cache"));
#include "ipc/ipc_message_macros.h"
#define private public
-#include "content/common/gpu/gpu_channel_manager.h"
+#include "gpu/ipc/service/gpu_channel_manager.h"
#include "content/gpu/in_process_gpu_thread.h"
#include "content/gpu/gpu_child_thread.h"
struct GpuChildThreadEfl : public content::GpuChildThread {
explicit GpuChildThreadEfl(const gpu::GpuPreferences& gpu_preferences,
const content::InProcessChildThreadParams& params,
- GpuMemoryBufferFactory* gpu_memory_buffer_factory,
- gpu::SyncPointManager* sync_point_manager)
+ gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory)
: GpuChildThread(gpu_preferences,
params,
- gpu_memory_buffer_factory,
- sync_point_manager) {}
+ gpu_memory_buffer_factory) {}
bool OnControlMessageReceived(const IPC::Message& msg) override {
bool handled = true;
struct InProcessGpuThreadEfl : public content::InProcessGpuThread {
explicit InProcessGpuThreadEfl(
const content::InProcessChildThreadParams& params,
- const gpu::GpuPreferences& gpu_preferences,
- gpu::SyncPointManager* sync_point_manager_override)
+ const gpu::GpuPreferences& gpu_preferences)
: InProcessGpuThread(params,
- gpu_preferences,
- sync_point_manager_override) {}
+ gpu_preferences) {}
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(
- gpu_preferences_, params_, gpu_memory_buffer_factory_.get(),
- sync_point_manager_override_));
+ gpu_preferences_, params_, gpu_memory_buffer_factory_.get()));
}
};
base::Thread* CreateInProcessGpuThread(
const content::InProcessChildThreadParams& params,
const gpu::GpuPreferences& gpu_preferences) {
- return new InProcessGpuThreadEfl(params, gpu_preferences, nullptr);
+ return new InProcessGpuThreadEfl(params, gpu_preferences);
}
} // namespace content
#include "base/compiler_specific.h"
#include "base/containers/hash_tables.h"
#include "content/common/content_export.h"
-#include "content/public/renderer/render_process_observer.h"
+#include "content/public/renderer/render_thread_observer.h"
#include "third_party/WebKit/public/platform/WebSpeechSynthesizer.h"
#include "third_party/WebKit/public/platform/WebSpeechSynthesizerClient.h"
// the utterance id (which is globally unique) matches.
class CONTENT_EXPORT TtsDispatcherEfl
: public blink::WebSpeechSynthesizer,
- public content::RenderProcessObserver {
+ public content::RenderThreadObserver {
public:
explicit TtsDispatcherEfl(blink::WebSpeechSynthesizerClient* client);
private:
virtual ~TtsDispatcherEfl();
- // RenderProcessObserver override.
+ // RenderThreadObserver override.
bool OnControlMessageReceived(const IPC::Message& message) override;
// blink::WebSpeechSynthesizer implementation.
} // namespace
-scoped_ptr<BatteryStatusManager> BatteryStatusManager::Create(
+std::unique_ptr<BatteryStatusManager> BatteryStatusManager::Create(
const BatteryStatusService::BatteryUpdateCallback& callback) {
- return scoped_ptr<BatteryStatusManager>(
+ return std::unique_ptr<BatteryStatusManager>(
new BatteryStatusManagerTizen(callback));
}
namespace device {
-scoped_ptr<VibrationProviderClient> VibrationManagerImplEfl::provider_client_ = scoped_ptr<VibrationProviderClient>();
+std::unique_ptr<VibrationProviderClient> VibrationManagerImplEfl::provider_client_ = std::unique_ptr<VibrationProviderClient>();
-void VibrationManagerImplEfl::Vibrate(int64_t milliseconds) {
+void VibrationManagerImplEfl::Vibrate(int64_t milliseconds, const VibrateCallback& callback) {
if (provider_client_.get())
provider_client_->Vibrate(milliseconds);
+ callback.Run();
}
-void VibrationManagerImplEfl::Cancel() {
+void VibrationManagerImplEfl::Cancel(const CancelCallback& callback) {
if (provider_client_.get())
provider_client_->CancelVibration();
+ callback.Run();
}
// static
#include "device/vibration/vibration_manager_impl.h"
-#include "base/memory/scoped_ptr.h"
#include "device/vibration/vibration_export.h"
#include "device/vibration/vibration_provider_client.h"
#include "mojo/public/cpp/bindings/strong_binding.h"
: binding_(this, std::move(request)) {}
~VibrationManagerImplEfl() override {}
- void Vibrate(int64_t milliseconds) override;
- void Cancel() override;
+ void Vibrate(int64_t milliseconds, const VibrateCallback& callback) override;
+ void Cancel(const CancelCallback& callback) override;
static void RegisterProviderClient(VibrationProviderClient* provider_client);
// The binding between this object and the other end of the pipe.
mojo::StrongBinding<VibrationManager> binding_;
- static scoped_ptr<VibrationProviderClient> provider_client_;
+ static std::unique_ptr<VibrationProviderClient> provider_client_;
};
} // namespace device
#ifndef VIBRATION_PROVIDER_CLIENT_H
#define VIBRATION_PROVIDER_CLIENT_H
+#include <stdint.h>
+
namespace device {
class VibrationProviderClient {
#include "content/common/paths_efl.h"
#include "content/public/common/content_switches.h"
#include "ui/compositor/compositor_switches.h"
-#include "ui/gfx/screen_efl.h"
+#include "ui/display/screen_efl.h"
#include "ui/gfx/switches.h"
#include "ui/gl/gl_switches.h"
#include "ui/ozone/public/ozone_platform.h"
namespace efl {
namespace {
-scoped_ptr<base::MessagePump> MessagePumpFactory() {
- return scoped_ptr<base::MessagePump>(new base::MessagePumpEcore);
+std::unique_ptr<base::MessagePump> MessagePumpFactory() {
+ return std::unique_ptr<base::MessagePump>(new base::MessagePumpEcore);
}
} // namespace
void AppendPortParams(base::CommandLine& cmdline) {
cmdline.AppendSwitchASCII(switches::kUseGL,
- gfx::kGLImplementationEGLName);
+ gl::kGLImplementationEGLName);
cmdline.AppendSwitch(switches::kInProcessGPU);
#if !defined(EWK_BRINGUP)
read_surface_(EGL_NO_SURFACE) {
// This should only used to restore a context that is not created or owned by
// Chromium native code, but created by Android system itself.
- DCHECK(!gfx::GLContext::GetCurrent());
+ DCHECK(!gl::GLContext::GetCurrent());
context_ = eglGetCurrentContext();
display_ = eglGetCurrentDisplay();
#include <audio_io.h>
#include <sound_manager.h>
-#include "base/memory/scoped_ptr.h"
#include "base/threading/thread.h"
#include "media/audio/audio_io.h"
#include "media/audio/audio_parameters.h"
char* buffer_;
media::InternalState state_;
AudioSourceCallback* source_callback_;
- s
coped_ptr<AudioBus> audio_bus_;
+ s
td::unique_ptr<AudioBus> audio_bus_;
DISALLOW_COPY_AND_ASSIGN(CapiAudioOutputStream);
};
#ifndef MEDIA_BASE_EFL_MEDIA_PLAYER_UTIL_EFL_H_
#define MEDIA_BASE_EFL_MEDIA_PLAYER_UTIL_EFL_H_
-#include "base/memory/scoped_ptr.h"
#include "media/base/media_export.h"
#include "url/gurl.h"
void operator()(media_packet_s* ptr) const;
};
-typedef scoped_ptr<media_packet_s, MediaPacketDeleter> ScopedMediaPacket;
+typedef std::unique_ptr<media_packet_s, MediaPacketDeleter> ScopedMediaPacket;
typedef enum {
MEDIA_SEEK_NONE, // No seek
#include <player.h>
-#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/timer/timer.h"
#include "base/tracked_objects.h"
#include <player.h>
#include "base/cancelable_callback.h"
-#include "base/memory/scoped_ptr.h"
#include "base/threading/thread.h"
#include "base/time/default_tick_clock.h"
#include "base/timer/timer.h"
// Constructs a player with the given ID and demuxer. |manager| must outlive
// the lifetime of this object.
MediaSourcePlayerCapi(
- int player_id, scoped_ptr<DemuxerEfl> demuxer,
+ int player_id, std::unique_ptr<DemuxerEfl> demuxer,
MediaPlayerManager* manager);
~MediaSourcePlayerCapi() override;
base::SharedMemoryHandle foreign_memory_handle,
const media::DemuxedBufferMetaData& meta_data);
- scoped_ptr<DemuxerEfl> demuxer_;
+ std::unique_ptr<DemuxerEfl> demuxer_;
const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
// Weak pointer passed to media decoder jobs for callbacks.
virtual ~VideoCaptureDeviceTizen() override;
virtual void AllocateAndStart(const VideoCaptureParams& params,
- scoped_ptr<Client> client) override;
+ std::unique_ptr<Client> client) override;
virtual void StopAndDeAllocate() override;
int height,
int frame_rate,
VideoPixelFormat format,
- scoped_ptr<Client> client);
+ std::unique_ptr<Client> client);
void OnStopAndDeAllocate();
void SetErrorState(const std::string& reason);
InternalState state_;
- scoped_ptr<VideoCaptureDevice::Client> client_;
+ std::unique_ptr<VideoCaptureDevice::Client> client_;
Name device_name_;
base::Thread worker_; // Thread used for reading data from the device.
- scoped_ptr<VideoCaptureDevice::Client::Buffer> buffer_;
+ std::unique_ptr<VideoCaptureDevice::Client::Buffer> buffer_;
camera_h camera_;
DISALLOW_IMPLICIT_CONSTRUCTORS(VideoCaptureDeviceTizen);
};
'base/tizen/media_source_player_capi.h',
'base/tizen/webaudio_decoder_browser_capi.cc',
'base/tizen/webaudio_decoder_browser_capi.h',
- 'capture/video/tizen/video_capture_device_factory_tizen.cc',
- 'capture/video/tizen/video_capture_device_factory_tizen.h',
- 'capture/video/tizen/video_capture_device_tizen.cc',
- 'capture/video/tizen/video_capture_device_tizen.h',
+# [M53_2785] Temporary disabling the codes for swiching to new chromium
+# It will be fixed by multimedia team
+# FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2061
+# 'capture/video/tizen/video_capture_device_factory_tizen.cc',
+# 'capture/video/tizen/video_capture_device_factory_tizen.h',
+# 'capture/video/tizen/video_capture_device_tizen.cc',
+# 'capture/video/tizen/video_capture_device_tizen.h',
],
'sources/': [
[ 'exclude', 'audio/linux/audio_manager_linux.cc$'],
#include "ui/base/resource/resource_handle.h"
#include "ui/base/ui_base_paths.h"
#include "ui/base/ui_base_switches.h"
-#include "ui/gfx/display.h"
+#include "ui/display/display.h"
#include "ui/gfx/image/image.h"
namespace {
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "ui/gfx/device_display_info_efl.h"
+#include "ui/display/device_display_info_efl.h"
#include "base/logging.h"
-namespace gfx {
+namespace display {
namespace {
} // namespace
// DeviceDisplayInfoEflImpl
-class GFX_EXPORT DeviceDisplayInfoEflImpl {
+class DISPLAY_EXPORT DeviceDisplayInfoEflImpl {
public:
static DeviceDisplayInfoEflImpl* GetInstance();
return DeviceDisplayInfoEflImpl::GetInstance()->GetRotationDegrees();
}
-} // namespace gfx
+} // namespace display
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef UI_GFX_DEVICE_DISPLAY_INFO_EFL_H_
-#define UI_GFX_DEVICE_DISPLAY_INFO_EFL_H_
+#ifndef UI_DISPLAY_DEVICE_DISPLAY_INFO_EFL_H_
+#define UI_DISPLAY_DEVICE_DISPLAY_INFO_EFL_H_
#include "base/memory/singleton.h"
#include "base/synchronization/lock.h"
-#include "ui/gfx/gfx_export.h"
+#include "ui/display/display_export.h"
-namespace gfx {
+namespace display {
// Facilitates access to device information in browser or renderer.
-class GFX_EXPORT DeviceDisplayInfoEfl {
+class DISPLAY_EXPORT DeviceDisplayInfoEfl {
public:
explicit DeviceDisplayInfoEfl();
DISALLOW_COPY_AND_ASSIGN(DeviceDisplayInfoEfl);
};
-} // namespace gfx
+} // namespace display
-#endif // UI_GFX_DEVICE_DISPLAY_INFO_EFL_H_
+#endif // UI_DISPLAY_DEVICE_DISPLAY_INFO_EFL_H_
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "ui/gfx/screen_efl.h"
+#include "ui/display/screen_efl.h"
#include "ecore_x_wayland_wrapper.h"
#include "content/browser/renderer_host/dip_util.h"
#include "ui/base/x/x11_util.h"
-#include "ui/gfx/device_display_info_efl.h"
+#include "ui/display/device_display_info_efl.h"
#include "ui/gfx/geometry/rect.h"
-#include "ui/gfx/display.h"
-#include "ui/gfx/display_observer.h"
+#include "ui/display/display.h"
+#include "ui/display/display_observer.h"
+#include "ui/display/screen.h"
#include "ui/gfx/geometry/dip_util.h"
-#include "ui/gfx/screen.h"
#include "ui/gfx/x/x11_types.h"
namespace ui {
-class ScreenEfl : public gfx::Screen {
+class ScreenEfl : public display::Screen {
public:
ScreenEfl() {
}
return gfx::Point();
}
- gfx::NativeWindow GetWindowUnderCursor() override {
+ bool IsWindowUnderCursor(gfx::NativeWindow window) override {
NOTIMPLEMENTED();
- return gfx::NativeWindow();
+ return false;
}
gfx::NativeWindow GetWindowAtScreenPoint(const gfx::Point& point) override {
return 1;
}
- std::vector<gfx::Display> GetAllDisplays() const override {
- return std::vector<gfx::Display>(1, GetPrimaryDisplay());
+ std::vector<display::Display> GetAllDisplays() const override {
+ return std::vector<display::Display>(1, GetPrimaryDisplay());
}
- gfx::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
+ display::Display GetDisplayNearestWindow(gfx::NativeView view) const override {
return GetPrimaryDisplay();
}
- gfx::Display GetDisplayNearestPoint(
+ display::Display GetDisplayNearestPoint(
const gfx::Point& point) const override {
return GetPrimaryDisplay();
}
- gfx::Display GetDisplayMatching(
+ display::Display GetDisplayMatching(
const gfx::Rect& match_rect) const override {
return GetPrimaryDisplay();
}
- gfx::Display GetPrimaryDisplay() const override {
- gfx::DeviceDisplayInfoEfl display_info;
+ display::Display GetPrimaryDisplay() const override {
+ display::DeviceDisplayInfoEfl display_info;
const float device_scale_factor =
- gfx::Display::HasForceDeviceScaleFactor() ?
- gfx::Display::GetForcedDeviceScaleFactor() : display_info.GetDIPScale();
+ display::Display::HasForceDeviceScaleFactor() ?
+ display::Display::GetForcedDeviceScaleFactor() : display_info.GetDIPScale();
- gfx::Display display(0);
+ display::Display display(0);
display.SetRotationAsDegree(display_info.GetRotationDegrees());
// TODO(prashant.n): Use DeviceDisplayInfoEfl for width and height.
// (http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14917)
int width, height;
#if defined(USE_WAYLAND)
- if (display.rotation() == gfx::Display::ROTATE_90 ||
- display.rotation() == gfx::Display::ROTATE_270) {
+ if (display.rotation() == display::Display::ROTATE_90 ||
+ display.rotation() == display::Display::ROTATE_270) {
ecore_wl_screen_size_get(&height, &width);
}
else {
#else
Ecore_X_Screen* screen = ecore_x_default_screen_get();
- if (display.rotation() == gfx::Display::ROTATE_90 ||
- display.rotation() == gfx::Display::ROTATE_270) {
+ if (display.rotation() == display::Display::ROTATE_90 ||
+ display.rotation() == display::Display::ROTATE_270) {
ecore_x_screen_size_get(screen, &height, &width);
}
else {
return display;
}
- void AddObserver(gfx::DisplayObserver* observer) override {
+ void AddObserver(display::DisplayObserver* observer) override {
}
- void RemoveObserver(gfx::DisplayObserver* observer) override {
+ void RemoveObserver(display::DisplayObserver* observer) override {
}
private:
static bool installed = false;
if (!installed) {
installed = true;
- gfx::Screen::SetScreenInstance(new ui::ScreenEfl());
+ display::Screen::SetScreenInstance(new ui::ScreenEfl());
}
}
} // namespace ui
-namespace gfx {
+namespace display {
Screen* CreateNativeScreen() {
return new ui::ScreenEfl();
}
-} // namespace gfx
+} // namespace display
#include <X11/Xutil.h>
-namespace gfx {
+namespace gl {
// Helper classes implementation.
class NativeDisplayConnection {
}
-} // namespace gfx
+} // namespace gl
#include "base/containers/hash_tables.h"
#include "base/containers/scoped_ptr_hash_map.h"
#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gl/gl_bindings.h"
#include <X11/Xlib.h>
#endif
-namespace gfx {
+namespace gl {
class NativeBuffer;
DISALLOW_COPY_AND_ASSIGN(EflPixmapImpl);
};
-} // namespace gfx
+} // namespace gl
#endif // UI_GL_EFL_PIXMAP_H_
#undef GLContextEGL
-namespace gfx {
+namespace gl {
class GL_EXPORT GLContextEGL : public GLContextEGLOverride {
public:
#include "ui/gl/gl_implementation_osmesa.h"
#include "gpu/command_buffer/service/texture_manager.h"
-using namespace gfx;
+using namespace gl;
extern void* GLGetCurentContext() {
#ifndef UI_GL_GL_IMAGE_EFL_PIXMAP_H_
#define UI_GL_GL_IMAGE_EFL_PIXMAP_H_
-#include "base/memory/scoped_ptr.h"
#include "ui/gl/gl_image.h"
#include "ui/gfx/gpu_memory_buffer.h"
#include "ui/gl/gl_bindings.h"
// and efl gl includes.
extern void* GLGetCurentContext();
-struct GLSharedContextEflPrivate : public gfx::GLContext {
+struct GLSharedContextEflPrivate : public gl::GLContext {
GLSharedContextEflPrivate(Evas_Object* object)
: GLContext(GLSharedContextEfl::GetShareGroup()) {
Evas* evas = evas_object_evas_get(object);
}
bool Initialize(
- gfx::GLSurface*, gfx::GpuPreference) override {
+ gl::GLSurface*, gl::GpuPreference) override {
NOTREACHED();
return false;
}
- bool MakeCurrent(gfx::GLSurface*) override {
+ bool MakeCurrent(gl::GLSurface*) override {
NOTREACHED();
return false;
}
- void ReleaseCurrent(gfx::GLSurface*) override {
+ void ReleaseCurrent(gl::GLSurface*) override {
NOTREACHED();
}
- bool IsCurrent(gfx::GLSurface*) override {
+ bool IsCurrent(gl::GLSurface*) override {
NOTREACHED();
return false;
}
return handle_;
}
- virtual scoped_refptr<gfx::GPUTimingClient> CreateGPUTimingClient() override {
+ virtual scoped_refptr<gl::GPUTimingClient> CreateGPUTimingClient() override {
return 0;
}
}
// static
-gfx::GLContext* GLSharedContextEfl::GetInstance() {
+gl::GLContext* GLSharedContextEfl::GetInstance() {
return g_private_part;
}
}
// static
-gfx::GLShareGroup* GLSharedContextEfl::GetShareGroup() {
- static scoped_refptr<gfx::GLShareGroup> share_group_ =
- new gfx::GLShareGroup();
+gl::GLShareGroup* GLSharedContextEfl::GetShareGroup() {
+ static scoped_refptr<gl::GLShareGroup> share_group_ =
+ new gl::GLShareGroup();
return share_group_.get();
}
typedef struct _Evas_GL_Context Evas_GL_Context;
-namespace gfx {
+namespace gl {
class GLContext;
class GLShareGroup;
}
struct GL_EXPORT GLSharedContextEfl {
static void Initialize(Evas_Object* object);
- static gfx::GLContext* GetInstance();
+ static gl::GLContext* GetInstance();
static Evas_GL_Context* GetEvasGLContext();
- static gfx::GLShareGroup* GetShareGroup();
+ static gl::GLShareGroup* GetShareGroup();
};
#endif
return gpu_platform_host_.get();
}
- scoped_ptr<SystemInputInjector> CreateSystemInputInjector() override {
+ std::unique_ptr<SystemInputInjector> CreateSystemInputInjector() override {
NOTIMPLEMENTED();
return NULL;
}
- s
coped_ptr<PlatformWindow> CreatePlatformWindow(
+ s
td::unique_ptr<PlatformWindow> CreatePlatformWindow(
PlatformWindowDelegate* delegate,
const gfx::Rect& bounds) override {
NOTIMPLEMENTED();
return NULL;
}
- scoped_ptr<ui::NativeDisplayDelegate> CreateNativeDisplayDelegate() override {
+ std::unique_ptr<ui::NativeDisplayDelegate> CreateNativeDisplayDelegate() override {
NOTIMPLEMENTED();
return NULL;
}
gpu_platform_.reset(CreateStubGpuPlatformSupport());
}
- scoped_ptr<SurfaceFactoryEfl> surface_factory_;
- scoped_ptr<GpuPlatformSupport> gpu_platform_;
- scoped_ptr<GpuPlatformSupportHost> gpu_platform_host_;
- scoped_ptr<OverlayManagerOzone> overlay_manager_;
+ std::unique_ptr<SurfaceFactoryEfl> surface_factory_;
+ std::unique_ptr<GpuPlatformSupport> gpu_platform_;
+ std::unique_ptr<GpuPlatformSupportHost> gpu_platform_host_;
+ std::unique_ptr<OverlayManagerOzone> overlay_manager_;
DISALLOW_COPY_AND_ASSIGN(OzonePlatformEfl);
};
#include "base/logging.h"
#include "base/numerics/safe_conversions.h"
#include "base/task_runner_util.h"
-#include "ui/gfx/display.h"
+#include "ui/display/display.h"
#include "ui/gfx/image/image.h"
#include "ui/gfx/geometry/rect.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/screen.h"
namespace ui {
'sources': [
'<(DEPTH)/ui/gfx/nine_image_painter.cc',
'<(DEPTH)/ui/gfx/nine_image_painter.h',
- 'gfx/device_display_info_efl.cc',
- 'gfx/device_display_info_efl.h',
- 'gfx/screen_efl.h',
- 'gfx/screen_efl.cc',
+ 'display/device_display_info_efl.cc',
+ 'display/device_display_info_efl.h',
+ 'display/screen_efl.h',
+ 'display/screen_efl.cc',
],
}],
'unittest/ewk-tests.gypi:*',
'ubrowser/ubrowser.gypi:*',
'efl_webview_app/efl_webview_app.gypi:*',
- '../../chrome/chrome_tests.gypi:chromedriver',
],
},
],
#include "browser/autofill/personal_data_manager_factory.h"
-#include "base/memory/scoped_ptr.h"
#include "browser/webdata/web_data_service_factory.h"
#include "components/autofill/core/browser/personal_data_manager.h"
#include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
, waiting_for_clear_quota_managed_data_(false) {
if (browser_context_) {
app_cache_service_ = browser_context->GetStoragePartition(browser_context_, NULL)->GetAppCacheService();
- main_context_getter_ = browser_context->GetRequestContext();
- media_context_getter_ = browser_context->GetMediaRequestContext();
+ main_context_getter_ =
+ content::BrowserContext::GetDefaultStoragePartition(browser_context_)->GetURLRequestContext();
+ media_context_getter_ = browser_context->CreateMediaRequestContext();
}
}
&geolocation_valid);
if (geolocation_valid) {
- scoped_ptr<_Ewk_Geolocation_Permission_Request> request(
+ std::unique_ptr<_Ewk_Geolocation_Permission_Request> request(
new _Ewk_Geolocation_Permission_Request(requesting_frame, callback));
// 'callback_result' is currently unused in webkit-efl implementation.
void SetPopupSize(int width, int height);
private:
- scoped_ptr<JavaScriptModalDialogEfl> dialog_;
- scoped_ptr<JavaScriptModalCallbacksData> alert_callback_data_;
- scoped_ptr<JavaScriptModalCallbacksData> confirm_callback_data_;
- scoped_ptr<JavaScriptModalCallbacksData> prompt_callback_data_;
+ std::unique_ptr<JavaScriptModalDialogEfl> dialog_;
+ std::unique_ptr<JavaScriptModalCallbacksData> alert_callback_data_;
+ std::unique_ptr<JavaScriptModalCallbacksData> confirm_callback_data_;
+ std::unique_ptr<JavaScriptModalCallbacksData> prompt_callback_data_;
DialogClosedCallback dialog_closed_callback_;
DISALLOW_COPY_AND_ASSIGN(JavaScriptDialogManagerEfl);
#define LOGIN_DELEGATE_EFL_H_
#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string16.h"
#include "content/public/browser/resource_dispatcher_host_login_delegate.h"
void NotificationControllerEfl::NotificationAdd(uint64_t notification_id,
const GURL& origin, const base::string16& replace_id,
- scoped_ptr<DesktopNotificationDelegate> delegate) {
+ std::unique_ptr<DesktopNotificationDelegate> delegate) {
NotificationData* new_notification(
new NotificationData(origin, replace_id, std::move(delegate)));
notifications_map_.AddWithID(new_notification, notification_id);
return true;
}
-blink::WebNotificationPermission NotificationControllerEfl::CheckPermissionOnUIThread(
+blink::mojom::PermissionStatus NotificationControllerEfl::CheckPermissionOnUIThread(
BrowserContext* browser_context,
const GURL& origin,
int render_process_id) {
return CheckPermissionForOrigin(origin);
}
-blink::WebNotificationPermission NotificationControllerEfl::CheckPermissionOnIOThread(
+blink::mojom::PermissionStatus NotificationControllerEfl::CheckPermissionOnIOThread(
ResourceContext* resource_context,
const GURL& origin,
int render_process_id) {
const GURL& origin,
const PlatformNotificationData& notification_data,
const NotificationResources& notification_resources,
- scoped_ptr<DesktopNotificationDelegate> delegate,
+ std::unique_ptr<DesktopNotificationDelegate> delegate,
base::Closure* cancel_callback) {
BrowserContextEfl* browser_context_efl =
permissions_map_[origin] = allowed;
}
-blink::WebNotificationPermission
+blink::mojom::PermissionStatus
NotificationControllerEfl::CheckPermissionForOrigin(
const GURL &origin) const {
base::AutoLock locker(permissions_mutex_);
std::map<GURL, bool>::const_iterator it = permissions_map_.find(origin);
if (it == permissions_map_.end())
- return blink::WebNotificationPermissionDefault;
+ return blink::mojom::PermissionStatus::ASK;
return it->second ?
- blink::WebNotificationPermissionAllowed :
- blink::WebNotificationPermissionDenied;
+ blink::mojom::PermissionStatus::GRANTED :
+ blink::mojom::PermissionStatus::DENIED;
}
void NotificationControllerEfl::ClearPermissions() {
result_callback.Run(PermissionStatus::DENIED);
return;
}
- scoped_ptr<Ewk_Notification_Permission_Request> notification_permission(
+ std::unique_ptr<Ewk_Notification_Permission_Request> notification_permission(
new Ewk_Notification_Permission_Request(web_view->evas_object(),
result_callback, requesting_frame));
return;
}
- blink::WebNotificationPermission web_notification_permission =
+ blink::mojom::PermissionStatus web_notification_permission =
CheckPermissionForOrigin(requesting_frame);
if (web_notification_permission ==
- blink::WebNotificationPermissionDefault) {
+ blink::mojom::PermissionStatus::LAST) {
web_view->InvokeNotificationPermissionCallback(
notification_permission.get());
// if policy is suspended, the API takes over the policy object lifetime
return;
}
} else {
- if (web_notification_permission == blink::WebNotificationPermissionAllowed) {
+ if (web_notification_permission == blink::mojom::PermissionStatus::GRANTED) {
result_callback.Run(PermissionStatus::GRANTED);
} else {
result_callback.Run(PermissionStatus::DENIED);
#include <Eina.h>
#include "base/id_map.h"
-#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/synchronization/lock.h"
#include "content/public/browser/desktop_notification_delegate.h"
struct NotificationData {
const std::string origin_url;
const base::string16 replace_id;
- scoped_ptr<DesktopNotificationDelegate> notification_delegate;
+ std::unique_ptr<DesktopNotificationDelegate> notification_delegate;
NotificationData(const GURL& origin,
const base::string16& replaceid,
- scoped_ptr<DesktopNotificationDelegate> delegate)
+ std::unique_ptr<DesktopNotificationDelegate> delegate)
: origin_url(origin.spec()),
replace_id(replaceid),
notification_delegate(std::move(delegate)) {}
// Adds a new notification received from engine to a list
void NotificationAdd(uint64_t notification_id, const GURL& origin,
const base::string16& replace_id,
- scoped_ptr<DesktopNotificationDelegate> delegate);
+ std::unique_ptr<DesktopNotificationDelegate> delegate);
bool NotificationClosed(uint64_t notification_id, bool by_user);
Ewk_Notification_Cancel_Callback close_callback, void* user_data);
/* PlatformNotificationService */
- blink::WebNotificationPermission CheckPermissionOnUIThread(
+ blink::mojom::PermissionStatus CheckPermissionOnUIThread(
BrowserContext* browser_context, const GURL& origin,
int render_process_id) override;
// JavaScript getter, and should not be used for other purposes. See
// https://crbug.com/446497 for the plan to deprecate this method.
// This method must only be called on the IO thread.
- blink::WebNotificationPermission CheckPermissionOnIOThread(
+ blink::mojom::PermissionStatus CheckPermissionOnIOThread(
ResourceContext* resource_context,
const GURL& origin,
int render_process_id) override;
const GURL& origin,
const PlatformNotificationData& notification_data,
const NotificationResources& notification_resources,
- scoped_ptr<DesktopNotificationDelegate> delegate,
+ std::unique_ptr<DesktopNotificationDelegate> delegate,
base::Closure* cancel_callback) override;
// Displays the persistent notification described in |notification_data| to
std::set<std::string>* displayed_notifications) override;
private:
- blink::WebNotificationPermission CheckPermissionForOrigin(
+ blink::mojom::PermissionStatus CheckPermissionForOrigin(
const GURL &origin) const;
IDMap<NotificationData, IDMapOwnPointer> notifications_map_; // This stores the notifications displayed to the user
void UseResponseOnIOThread();
void IgnoreResponseOnIOThread();
- scoped_ptr<_Ewk_Policy_Decision> policy_decision_;
+ std::unique_ptr<_Ewk_Policy_Decision> policy_decision_;
// A throttle which blocks response and invokes policy mechanism.
// It is used to cancel or resume response processing.
ResourceThrottleEfl* throttle_;
content::ResourceContext* resource_context,
int child_id,
int route_id,
- int request_id,
bool is_content_initiated,
bool must_download,
ScopedVector<content::ResourceThrottle>* throttles) {
content::ResourceContext* resource_context,
int child_id,
int route_id,
- int request_id,
bool is_content_initiated,
bool must_download,
ScopedVector<content::ResourceThrottle>* throttles) override;
#ifndef popup_menu_item_private_h
#define popup_menu_item_private_h
-#include "config.h"
#include "popup_menu_item.h"
-#include "base/memory/scoped_ptr.h"
#include "content/public/common/menu_item.h"
#include "third_party/WebKit/public/web/WebTextDirection.h"
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "config.h"
#include "popup_picker.h"
#include "popup_menu_item.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"
#include "browser_context_efl.h"
-#include "android_webview/browser/aw_pref_store.h"
#include "base/bind.h"
#include "base/files/file_util.h"
#include "base/path_service.h"
#include "components/autofill/core/browser/personal_data_manager.h"
#include "components/autofill/core/common/autofill_pref_names.h"
#include "components/password_manager/core/common/password_manager_pref_names.h"
+#include "components/prefs/in_memory_pref_store.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
#include "components/prefs/pref_service_factory.h"
return getter_->GetURLRequestContext();
}
+net::URLRequestContextGetter* BrowserContextEfl::CreateMediaRequestContext() {
+ return request_context_getter_.get();
+}
+
+net::URLRequestContextGetter* BrowserContextEfl::CreateMediaRequestContextForStoragePartition(const base::FilePath&, bool) {
+ return nullptr;
+}
+
void BrowserContextEfl::ResourceContextEfl::set_url_request_context_getter(
URLRequestContextGetterEfl* getter) {
getter_ = getter;
pref_registry->RegisterBooleanPref(kPasswordManagerSavingEnabled, true);
PrefServiceFactory pref_service_factory;
- pref_service_factory.set_user_prefs(make_scoped_refptr(new AwPrefStore));
+ pref_service_factory.set_user_prefs(make_scoped_refptr(new InMemoryPrefStore()));
pref_service_factory.set_read_error_callback(base::Bind(&HandleReadError));
user_pref_service_ = std::move(pref_service_factory.Create(pref_registry));
BrowserContext::Initialize(this, GetPath());
}
-net::URLRequestContextGetter* BrowserContextEfl::GetRequestContext() {
- if (!request_context_getter_.get()) {
- // this will trigger a call to CreateRequestContext
- GetStoragePartition(this, NULL);
- DCHECK(request_context_getter_.get());
- }
- return request_context_getter_.get();
-}
-
-scoped_ptr<ZoomLevelDelegate> BrowserContextEfl::CreateZoomLevelDelegate(
+std::unique_ptr<ZoomLevelDelegate> BrowserContextEfl::CreateZoomLevelDelegate(
const base::FilePath&) {
- return scoped_ptr<ZoomLevelDelegate>();
+ return std::unique_ptr<ZoomLevelDelegate>();
}
ResourceContext* BrowserContextEfl::GetResourceContext() {
if (!network_delegate_for_getter_.get()) {
// NetWorkDelegate must be created on IO thread
- base::WaitableEvent done(false, false);
+ base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+ base::WaitableEvent::InitialState::NOT_SIGNALED);
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(CreateNetworkDelegateOnIOThread, this, &done));
ScopedAllowWaitForLegacyWebViewApi allow_wait;
#include "url_request_context_getter_efl.h"
#include "base/files/scoped_temp_dir.h"
-#include "base/memory/scoped_ptr.h"
#include "base/synchronization/lock.h"
#include "browser/download_manager_delegate_efl.h"
#include "browser/geolocation/geolocation_permission_context_efl.h"
virtual net::HostResolver* GetHostResolver() override;
virtual net::URLRequestContext* GetRequestContext() override;
-
void set_url_request_context_getter(URLRequestContextGetterEfl* getter);
scoped_refptr<CookieManager> GetCookieManager() const;
BrowserContextEfl(EWebContext*, bool incognito = false);
~BrowserContextEfl();
- virtual scoped_ptr<ZoomLevelDelegate> CreateZoomLevelDelegate(
+ net::URLRequestContextGetter* CreateMediaRequestContext() override;
+ net::URLRequestContextGetter* CreateMediaRequestContextForStoragePartition(const base::FilePath&, bool) override;
+ virtual std::unique_ptr<ZoomLevelDelegate> CreateZoomLevelDelegate(
const base::FilePath& partition_path);
virtual bool IsOffTheRecord() const override { return incognito_; }
- virtual net::URLRequestContextGetter* GetRequestContext() override;
URLRequestContextGetterEfl* GetRequestContextEfl()
{ return request_context_getter_.get(); }
- virtual net::URLRequestContextGetter* GetMediaRequestContext() override
- { return GetRequestContext(); }
- virtual net::URLRequestContextGetter* GetMediaRequestContextForRenderProcess(int) override
- { return GetRequestContext(); }
- virtual net::URLRequestContextGetter* GetMediaRequestContextForStoragePartition(
- const base::FilePath&, bool) override
- { return GetRequestContext(); }
// These methods map to Add methods in visitedlink::VisitedLinkMaster.
void AddVisitedURLs(const std::vector<GURL>& urls);
private:
static void ReadCertificateAndAdd(base::FilePath* file_path);
virtual SSLHostStateDelegate* GetSSLHostStateDelegate() override;
- mutable scoped_ptr<GeolocationPermissionContextEfl>
+ mutable std::unique_ptr<GeolocationPermissionContextEfl>
geolocation_permission_context_;
- scoped_ptr<visitedlink::VisitedLinkMaster> visitedlink_master_;
+ std::unique_ptr<visitedlink::VisitedLinkMaster> visitedlink_master_;
ResourceContextEfl* resource_context_;
scoped_refptr<URLRequestContextGetterEfl> request_context_getter_;
DownloadManagerDelegateEfl download_manager_delegate_;
base::ScopedTempDir temp_dir_;
bool temp_dir_creation_attempted_;
- s
coped_ptr<PrefService> user_pref_service_;
+ s
td::unique_ptr<PrefService> user_pref_service_;
const bool incognito_;
- scoped_ptr<net::NetworkDelegate> network_delegate_for_getter_;
- scoped_ptr<SSLHostStateDelegateEfl> ssl_host_state_delegate_;
- s
coped_ptr<PermissionManager> permission_manager_;
+ std::unique_ptr<net::NetworkDelegate> network_delegate_for_getter_;
+ std::unique_ptr<SSLHostStateDelegateEfl> ssl_host_state_delegate_;
+ s
td::unique_ptr<PermissionManager> permission_manager_;
DISALLOW_COPY_AND_ASSIGN(BrowserContextEfl);
};
#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"
namespace devtools_http_handler {
// For reuse of timers with message pump
command_line->AppendSwitch(switches::kLimitMemoryAllocationInScheduleDelayedWork);
- // For testing link disambiguation popup
- command_line->AppendSwitch(switches::kEnableLinkDisambiguationPopup);
-
}
#include <string>
#include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
#include "build/tizen_version.h"
namespace EflWebView {
#include "command_line_efl.h"
#include "base/callback.h"
-#include "base/memory/scoped_ptr.h"
#include "base/strings/string_number_conversions.h"
#include "browser_main_parts_efl.h"
#include "browser_context_efl.h"
return browser_main_parts_efl_;
}
-AccessTokenStore* ContentBrowserClientEfl::CreateAccessTokenStore() {
- return new AccessTokenStoreEfl();
-}
-
-#if defined(OS_TIZEN)
-LocationProvider* ContentBrowserClientEfl::OverrideSystemLocationProvider() {
- return LocationProviderEfl::Create();
-}
-#endif
-
void ContentBrowserClientEfl::AppendExtraCommandLineSwitches(base::CommandLine* command_line,
int child_process_id) {
if (command_line->HasSwitch(switches::kProcessType)) {
int render_process_id, const GURL &target_url) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- scoped_ptr<RenderWidgetHostIterator> widgets(
+ std::unique_ptr<RenderWidgetHostIterator> widgets(
RenderWidgetHost::GetRenderWidgetHosts());
RenderWidgetHost* widget = NULL;
#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"
namespace base {
class CommandLine;
virtual BrowserMainParts* CreateBrowserMainParts(
const MainFunctionParams& parameters) override;
- virtual AccessTokenStore* CreateAccessTokenStore() override;
-#if defined(OS_TIZEN)
- virtual LocationProvider* OverrideSystemLocationProvider() override;
-#endif
-
// Allows the embedder to pass extra command line flags.
// switches::kProcessType will already be set at this point.
virtual void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
static void DispatchPopupBlockedOnUIThread(int render_process_id,
const GURL &target_url);
- scoped_ptr<ResourceDispatcherHostDelegateEfl> resource_disp_host_del_efl_;
+ std::unique_ptr<ResourceDispatcherHostDelegateEfl> resource_disp_host_del_efl_;
BrowserMainPartsEfl* browser_main_parts_efl_;
#if defined(ENABLE_NOTIFICATIONS)
- scoped_ptr<NotificationControllerEfl> notification_controller_;
+ std::unique_ptr<NotificationControllerEfl> notification_controller_;
#endif
DISALLOW_COPY_AND_ASSIGN(ContentBrowserClientEfl);
private:
void PreSandboxStartupBrowser();
- scoped_ptr<ContentBrowserClient> browser_client_;
- scoped_ptr<ContentRendererClient> renderer_client_;
+ std::unique_ptr<ContentBrowserClient> browser_client_;
+ std::unique_ptr<ContentRendererClient> renderer_client_;
ContentClientEfl content_client_;
DISALLOW_COPY_AND_ASSIGN(ContentMainDelegateEfl);
};
DownloadManager* dlm = BrowserContext::GetDownloadManager(
web_contents_.GetBrowserContext());
- scoped_ptr<DownloadUrlParameters> dl_params(
- DownloadUrlParameters::FromWebContents(&web_contents_, url));
+ std::unique_ptr<DownloadUrlParameters> dl_params(
+ DownloadUrlParameters::CreateForWebContentsMainFrame(&web_contents_, url));
dl_params->set_post_id(-1);
dl_params->set_referrer(
content::Referrer(referrer, blink::WebReferrerPolicyAlways));
bool is_text_selection_;
std::set<DownloadItem*> clipboard_download_items_;
std::set<DownloadItem*> disk_download_items_;
- scoped_ptr<JavaScriptModalDialogEfl> file_saved_dialog_;
- scoped_ptr<JavaScriptModalDialogEfl> save_fail_dialog_;
+ std::unique_ptr<JavaScriptModalDialogEfl> file_saved_dialog_;
+ std::unique_ptr<JavaScriptModalDialogEfl> save_fail_dialog_;
};
} // namespace
#include "base/bind.h"
#include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
#include "base/stl_util.h"
#include "base/synchronization/waitable_event.h"
#include "content/public/browser/browser_thread.h"
+#include "content/browser/storage_partition_impl.h"
#include "browser/scoped_allow_wait_for_legacy_web_view_api.h"
#include "eweb_context.h"
#include "net/base/net_errors.h"
void CookieManager::DeleteSessionCookiesOnIOThread() {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
- scoped_ptr<net::CookieStore> cookie_store = GetCookieStore();
+ std::unique_ptr<net::CookieStore> cookie_store = GetCookieStore();
if (cookie_store.get())
cookie_store->DeleteSessionCookiesAsync(base::Callback<void(int)>());
}
-static void DeleteCookiesOnIOThread(scoped_ptr<net::CookieStore> cookie_store,
+static void DeleteCookiesOnIOThread(std::unique_ptr<net::CookieStore> cookie_store,
const std::string& url,
const std::string& cookie_name) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
return;
if (cookie_name.empty()) {
// Delete all matching host cookies.
- cookie_store->DeleteAllCreatedBetweenForHostAsync(base::Time(), base::Time::Max(), gurl,
+ cookie_store->DeleteAllCreatedBetweenWithPredicateAsync(base::Time(), base::Time::Max(),
+ content::StoragePartitionImpl::CreatePredicateForHostCookies(gurl),
net::CookieMonster::DeleteCallback());
} else {
// Delete all matching host and domain cookies.
const std::string& cookie_name)
{
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- scoped_ptr<net::CookieStore> cookie_store = GetCookieStore();
+ std::unique_ptr<net::CookieStore> cookie_store = GetCookieStore();
if (cookie_store.get()) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
void CookieManager::GetHostNamesWithCookiesAsync(AsyncHostnamesGetCb callback, void *data) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
host_callback_queue_.push(new EwkGetHostCallback(callback, data));
- scoped_ptr<net::CookieStore> cookie_store = GetCookieStore();
+ std::unique_ptr<net::CookieStore> cookie_store = GetCookieStore();
if (cookie_store.get()) {
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
}
void CookieManager::FetchCookiesOnIOThread(
- scoped_ptr<net::CookieStore> cookie_store) {
+ std::unique_ptr<net::CookieStore> cookie_store) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
if (cookie_store.get()) {
completion->Signal();
}
-static void GetCookieValueOnIOThread(scoped_ptr<net::CookieStore> cookie_store,
+static void GetCookieValueOnIOThread(std::unique_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_ptr<net::CookieStore> cookie_store = GetCookieStore();
+ std::unique_ptr<net::CookieStore> cookie_store = GetCookieStore();
if (!cookie_store.get())
return std::string();
std::string cookie_value;
- base::WaitableEvent completion(false, false);
+ base::WaitableEvent completion(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+ base::WaitableEvent::InitialState::NOT_SIGNALED);
BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
base::Bind(GetCookieValueOnIOThread,
base::Passed(std::move(cookie_store)),
return scoped_refptr<content::URLRequestContextGetterEfl>(request_context_getter_.get());
}
-scoped_ptr<net::CookieStore> CookieManager::GetCookieStore() const {
+std::unique_ptr<net::CookieStore> CookieManager::GetCookieStore() const {
scoped_refptr<content::URLRequestContextGetterEfl> request_context_getter = GetContextGetter();
if (request_context_getter.get()) {
- return scoped_ptr<net::CookieStore>(
+ return std::unique_ptr<net::CookieStore>(
request_context_getter->GetURLRequestContext()->cookie_store());
} else {
- return scoped_ptr<net::CookieStore>();
+ return std::unique_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_ptr<net::CookieStore> cookie_store);
+ void FetchCookiesOnIOThread(std::unique_ptr<net::CookieStore> cookie_store);
void OnFetchComplete(const net::CookieList& cookies);
scoped_refptr<CookieManager> GetSharedThis();
scoped_refptr<content::URLRequestContextGetterEfl> GetContextGetter() const;
- scoped_ptr<net::CookieStore> GetCookieStore() const;
+ std::unique_ptr<net::CookieStore> GetCookieStore() const;
scoped_refptr<content::URLRequestContextGetterEfl> request_context_getter_;
//cookie policy information
base::Lock lock_;
port_(port) {}
private:
- scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
- scoped_ptr<net::ServerSocket> socket(
+ std::unique_ptr<net::ServerSocket> CreateForHttpServer() override {
+ std::unique_ptr<net::ServerSocket> socket(
new net::TCPServerSocket(nullptr, net::NetLog::Source()));
if (socket->ListenWithAddressAndPort(address_, port_, kBackLog) != net::OK)
- return scoped_ptr<net::ServerSocket>();
+ return std::unique_ptr<net::ServerSocket>();
return socket;
}
// be creating async callbacks that would inform when inspector server started
// and on which port.
static std::string addr = "0.0.0.0";
- scoped_ptr<net::ServerSocket> sock(new net::TCPServerSocket(NULL, net::NetLog::Source()));
+ std::unique_ptr<net::ServerSocket> sock(new net::TCPServerSocket(NULL, net::NetLog::Source()));
const base::CommandLine* const command_line = base::CommandLine::ForCurrentProcess();
// See if the user specified a port on the command line (useful for
sock->GetLocalAddress(&givenIp);
port_ = givenIp.port();
- scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> factory(
+ std::unique_ptr<DevToolsHttpHandler::ServerSocketFactory> factory(
new TCPServerSocketFactory(addr, port_));
devtools_http_handler_.reset(new devtools_http_handler::DevToolsHttpHandler(
#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
#include "components/devtools_http_handler/devtools_http_handler_delegate.h"
namespace content {
private:
int port_;
content::BrowserContext* browser_context_;
- scoped_ptr<DevToolsHttpHandler> devtools_http_handler_;
+ std::unique_ptr<DevToolsHttpHandler> devtools_http_handler_;
};
} // namespace content
'<(DEPTH)/components/components.gyp:autofill_content_renderer',
'<(DEPTH)/components/components.gyp:autofill_content_browser',
'<(DEPTH)/components/components.gyp:devtools_http_handler',
+ '<(DEPTH)/components/components.gyp:network_session_configurator_switches',
'<(DEPTH)/components/components.gyp:password_manager_content_browser',
'<(DEPTH)/components/components.gyp:password_manager_core_common',
'<(DEPTH)/components/components.gyp:password_manager_core_browser',
'<(DEPTH)/printing/printing.gyp:printing',
'<(DEPTH)/skia/skia.gyp:skia',
'<(DEPTH)/storage/storage_browser.gyp:storage',
+ '<(DEPTH)/third_party/leveldatabase/leveldatabase.gyp:leveldatabase',
'<(DEPTH)/third_party/sqlite/sqlite.gyp:sqlite',
'<(DEPTH)/third_party/WebKit/Source/wtf/wtf.gyp:wtf',
'<(DEPTH)/ui/compositor/compositor.gyp:compositor',
'<(DEPTH)/ui/events/events.gyp:events',
'<(DEPTH)/ui/events/events.gyp:events_base',
'<(DEPTH)/ui/gl/gl.gyp:gl',
- '<(DEPTH)/v8/tools/gyp/v8.gyp:v8',
+ '<(DEPTH)/v8/src/v8.gyp:v8',
],
'defines': [
'browser/web_view_browser_message_filter.cc',
'browser/web_view_browser_message_filter.h',
- # Make use of Android webview's simplified pref class.
- '<(DEPTH)/android_webview/browser/aw_pref_store.h',
- '<(DEPTH)/android_webview/browser/aw_pref_store.cc',
+# [M53_2785] The AwPrefStore class was removed in m53.
+# It will be fixed by webview team.
+# FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2071
+# # Make use of Android webview's simplified pref class.
+# '<(DEPTH)/android_webview/browser/aw_pref_store.h',
+# '<(DEPTH)/android_webview/browser/aw_pref_store.cc',
'browser/autofill/autofill_client_efl.h',
'browser/autofill/autofill_client_efl.cc',
'browser/autofill/personal_data_manager_factory.cc',
'renderer/print_web_view_helper_efl.h',
'renderer/render_frame_observer_efl.cc',
'renderer/render_frame_observer_efl.h',
- 'renderer/render_process_observer_efl.cc',
- 'renderer/render_process_observer_efl.h',
+ 'renderer/render_thread_observer_efl.cc',
+ 'renderer/render_thread_observer_efl.h',
'renderer/render_view_observer_efl.cc',
'renderer/render_view_observer_efl.h',
net::ProxyService* proxy_service =
url_request_context_getter->GetURLRequestContext()->proxy_service();
proxy_service->ResetConfigService(
- make_scoped_ptr(new net::ProxyConfigServiceFixed(proxy_config)));
+ base::WrapUnique(new net::ProxyConfigServiceFixed(proxy_config)));
done->Signal();
}
void* user_data,
content::StoragePartition* partition) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
- scoped_ptr<storage::FileSystemQuotaClient> client( new storage::FileSystemQuotaClient(partition->GetFileSystemContext(), false));
+ std::unique_ptr<storage::FileSystemQuotaClient> client( new storage::FileSystemQuotaClient(partition->GetFileSystemContext(), false));
client->GetOriginsForType(storage::kStorageTypeTemporary,
base::Bind(&OnGetFileSystemOrigins, callback, user_data));
// there are ewk_cookie_manager APIs that can be called before a
// WebView instance is created. In such circumstances, APIs including
// ewk_cookie_manager_persistent_storage_set fail to execute.
- browser_context_->GetRequestContext();
+ BrowserContext::GetDefaultStoragePartition(browser_context())->GetURLRequestContext();
// Notification Service gets init in BrowserMainRunner init,
// so cache manager can register for notifications only after that.
}
void EWebContext::SetNetworkCacheEnable(bool enable) {
- net::URLRequestContext* url_context = browser_context_->GetRequestContext()->GetURLRequestContext();
+ net::URLRequestContextGetter* url_context = BrowserContext::GetDefaultStoragePartition(browser_context())->GetURLRequestContext();
if (!url_context)
return;
- net::HttpTransactionFactory* transaction_factory = url_context->http_transaction_factory();
+ net::HttpTransactionFactory* transaction_factory = url_context->GetURLRequestContext()->http_transaction_factory();
if (!transaction_factory)
return;
}
bool EWebContext::GetNetworkCacheEnable() const {
- net::HttpCache* http_cache = browser_context_->GetRequestContext()->GetURLRequestContext()->
- http_transaction_factory()->GetCache();
+ net::HttpCache* http_cache = BrowserContext::GetDefaultStoragePartition(browser_context())->GetURLRequestContext()->
+ GetURLRequestContext()->http_transaction_factory()->GetCache();
if (!http_cache)
return false;
proxy_uri_ = string(uri);
net::ProxyConfig config;
config.proxy_rules().ParseFromString(proxy_uri_);
- base::WaitableEvent done(false, false);
+ base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+ base::WaitableEvent::InitialState::NOT_SIGNALED);
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&SetProxyConfigCallbackOnIOThread, &done,
- base::RetainedRef(browser_context()->GetRequestContext()),
+ base::RetainedRef(BrowserContext::GetDefaultStoragePartition(browser_context())->GetURLRequestContext()),
config));
done.Wait();
}
#define EWEB_CONTEXT_H
#include "base/files/file_path.h"
-#include "base/memory/scoped_ptr.h"
#include "browser/web_cache_efl/web_cache_manager_efl.h"
#include "common/tizen_extensible.h"
#include "private/ewk_cookie_manager_private.h"
~EWebContext();
friend class Ewk_Context;
- scoped_ptr<WebCacheManagerEfl> web_cache_manager_;
- scoped_ptr<content::BrowserContextEfl> browser_context_;
- scoped_ptr<Ewk_Cookie_Manager> ewk_cookie_manager_;
- scoped_ptr<TizenExtensible> tizen_extensible_;
- scoped_ptr<EwkFaviconDatabase> ewk_favicon_database_;
+ std::unique_ptr<WebCacheManagerEfl> web_cache_manager_;
+ std::unique_ptr<content::BrowserContextEfl> browser_context_;
+ std::unique_ptr<Ewk_Cookie_Manager> ewk_cookie_manager_;
+ std::unique_ptr<TizenExtensible> tizen_extensible_;
+ std::unique_ptr<EwkFaviconDatabase> ewk_favicon_database_;
std::string proxy_uri_;
std::string injected_bundle_path_;
// widget info
std::string widget_encoded_bundle_;
double widget_scale_;
- scoped_ptr<EwkDidStartDownloadCallback> start_download_callback_;
- scoped_ptr<EwkMimeOverrideCallback> mime_override_callback_;
+ std::unique_ptr<EwkDidStartDownloadCallback> start_download_callback_;
+ std::unique_ptr<EwkMimeOverrideCallback> mime_override_callback_;
int m_pixmap;
devtools_http_handler::DevToolsDelegateEfl* inspector_server_;
- scoped_ptr<EWebContextNotificationCallback> notification_cb_;
+ std::unique_ptr<EWebContextNotificationCallback> notification_cb_;
};
#endif
#include "web_contents_efl_delegate_ewk.h"
#include "web_contents_view_efl_delegate_ewk.h"
#include "ui/base/l10n/l10n_util.h"
-#include "ui/gfx/screen.h"
+#include "ui/display/screen.h"
#include "permission_popup_manager.cc"
#include "browser/web_view_evas_handler.h"
formIsNavigating_(false),
current_find_request_id_(find_request_id_counter_++),
progress_(0.0),
- hit_test_completion_(false, false),
+ hit_test_completion_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+ base::WaitableEvent::InitialState::NOT_SIGNALED),
page_scale_factor_(1.0),
is_initialized_(false) {
}
SmartCallback<EWebViewCallbacks::SaveSessionData>().call();
- scoped_ptr<_Ewk_Policy_Decision> policy_decision(new _Ewk_Policy_Decision(params, rvh));
+ std::unique_ptr<_Ewk_Policy_Decision> policy_decision(new _Ewk_Policy_Decision(params, rvh));
SmartCallback<EWebViewCallbacks::NavigationPolicyDecision>().call(policy_decision.get());
if (!is_main_frame)
return;
- scoped_ptr<_Ewk_Error> err(new _Ewk_Error(error_code,
+ std::unique_ptr<_Ewk_Error> err(new _Ewk_Error(error_code,
url.possibly_invalid_spec().c_str(), error_description.c_str()));
SmartCallback<EWebViewCallbacks::LoadError>().call(err.get());
}
void EWebView::SelectLinkText(const gfx::Point& touch_point) {
- float device_scale_factor = gfx::Screen::GetScreen()->
+ float device_scale_factor = display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
RenderViewHost* render_view_host = web_contents_->GetRenderViewHost();
render_view_host->Send(new ViewMsg_SelectLinkText(
if (it == hit_test_callback_.end())
return;
- scoped_ptr<_Ewk_Hit_Test> hit_test(new _Ewk_Hit_Test(params));
+ std::unique_ptr<_Ewk_Hit_Test> hit_test(new _Ewk_Hit_Test(params));
it->second->Run(hit_test.get(), this);
delete it->second;
}
void EWebView::EvasToBlinkCords(int x, int y, int* view_x, int* view_y) {
- DCHECK(gfx::Screen::GetScreen());
+ DCHECK(display::Screen::GetScreen());
Evas_Coord tmpX, tmpY;
evas_object_geometry_get(evas_object_, &tmpX, &tmpY, NULL, NULL);
if (view_x) {
*view_x = x - tmpX;
- *view_x /= gfx::Screen::GetScreen()->
+ *view_x /= display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
}
if (view_y) {
*view_y = y - tmpY;
- *view_y /= gfx::Screen::GetScreen()->
+ *view_y /= display::Screen::GetScreen()->
GetPrimaryDisplay().device_scale_factor();
}
}
if (!entryCount)
return true;
- std::vector<scoped_ptr<content::NavigationEntry>> scopedEntries =
+ std::vector<std::unique_ptr<content::NavigationEntry>> scopedEntries =
sessions::ContentSerializedNavigationBuilder::ToNavigationEntries(
serializedEntries, context()->browser_context());
if (body) {
std::string s(body);
- params.browser_initiated_post_data =
- base::RefCountedString::TakeString(&s);
+ params.post_data = content::ResourceRequestBody::CreateFromBytes(
+ s.data(), s.size());
}
net::HttpRequestHeaders header;
#include "base/callback.h"
#include "base/id_map.h"
-#include "base/memory/scoped_ptr.h"
#include "base/synchronization/waitable_event.h"
#include "browser/inputpicker/InputPicker.h"
#include "browser/selectpicker/popup_picker.h"
scoped_refptr<WebViewEvasEventHandler> evas_event_handler_;
scoped_refptr<Ewk_Context> context_;
scoped_refptr<Ewk_Context> old_context_;
- scoped_ptr<content::WebContents> web_contents_;
- scoped_ptr<content::WebContentsDelegateEfl> web_contents_delegate_;
+ std::unique_ptr<content::WebContents> web_contents_;
+ std::unique_ptr<content::WebContentsDelegateEfl> web_contents_delegate_;
std::string pending_url_request_;
- scoped_ptr<Ewk_Settings> settings_;
- scoped_ptr<_Ewk_Frame> frame_;
- scoped_ptr<_Ewk_Policy_Decision> window_policy_;
+ std::unique_ptr<Ewk_Settings> settings_;
+ std::unique_ptr<_Ewk_Frame> frame_;
+ std::unique_ptr<_Ewk_Policy_Decision> window_policy_;
Evas_Object* evas_object_;
Evas_Object* native_view_;
bool touch_events_enabled_;
double text_zoom_factor_;
mutable std::string user_agent_;
mutable std::string user_agent_app_name_;
- scoped_ptr<_Ewk_Auth_Challenge> auth_challenge_;
+ std::unique_ptr<_Ewk_Auth_Challenge> auth_challenge_;
Eina_List* popupMenuItems_;
Popup_Picker* popupPicker_;
bool nextState;
} formNavigation;
formNavigation formNavigation_;
- scoped_ptr<content::ContextMenuControllerEfl> context_menu_;
- scoped_ptr<content::FileChooserControllerEfl> file_chooser_;
- scoped_ptr<content::PopupControllerEfl> popup_controller_;
+ std::unique_ptr<content::ContextMenuControllerEfl> context_menu_;
+ std::unique_ptr<content::FileChooserControllerEfl> file_chooser_;
+ std::unique_ptr<content::PopupControllerEfl> popup_controller_;
base::string16 previous_text_;
int current_find_request_id_;
static int find_request_id_counter_;
WebViewCallback<Ewk_Quota_Permission_Request_Callback,
const _Ewk_Quota_Permission_Request*> quota_request_callback_;
- scoped_ptr<content::InputPicker> inputPicker_;
+ std::unique_ptr<content::InputPicker> inputPicker_;
IDMap<WebApplicationIconUrlGetCallback, IDMapOwnPointer> web_app_icon_url_get_callback_map_;
IDMap<WebApplicationIconUrlsGetCallback, IDMapOwnPointer> web_app_icon_urls_get_callback_map_;
IDMap<WebApplicationCapableGetCallback, IDMapOwnPointer> web_app_capable_get_callback_map_;
- s
coped_ptr<PermissionPopupManager> permission_popup_manager_;
- scoped_ptr<ScrollDetector> scroll_detector_;
+ s
td::unique_ptr<PermissionPopupManager> permission_popup_manager_;
+ std::unique_ptr<ScrollDetector> scroll_detector_;
#if defined(OS_TIZEN_MOBILE)
content::FileChooserParams::Mode filechooser_mode_;
bool is_initialized_;
- scoped_ptr<_Ewk_Back_Forward_List> back_forward_list_;
+ std::unique_ptr<_Ewk_Back_Forward_List> back_forward_list_;
static content::WebContentsEflDelegate::WebContentsCreateCallback
create_new_window_web_contents_cb_;
#include "command_line_efl.h"
#include "content_main_delegate_efl.h"
#include "message_pump_for_ui_efl.h"
-#include "ui/gfx/screen_efl.h"
+#include "ui/display/screen_efl.h"
#ifdef OS_TIZEN
#include <dlfcn.h>
namespace {
-scoped_ptr<base::MessagePump> MessagePumpFactory() {
- return scoped_ptr<base::MessagePump>(new base::MessagePumpForUIEfl);
+std::unique_ptr<base::MessagePump> MessagePumpFactory() {
+ return std::unique_ptr<base::MessagePump>(new base::MessagePumpForUIEfl);
}
} // namespace
}
}
+#if !defined(EWK_BRINGUP)
+// [M53_2785] The FilesSelectedInChooser function moved to RenderFrameHost from
+// RenderViewHost.
+// It will be fixed by webcore team.
+// FIXME: http://suprem.sec.samsung.net/jira/browse/TWF-2072
render_view_host->FilesSelectedInChooser(files, inst->GetParams()->mode);
+#endif // EWK_BRINGUP
evas_object_del(elm_object_top_widget_get(obj));
}
#define file_chooser_controller_efl_h
#include <Evas.h>
+#include "content/public/common/file_chooser_params.h"
namespace content {
'<(DEPTH)/ui/shell_dialogs/shell_dialogs.gyp:shell_dialogs',
'<(DEPTH)/ui/snapshot/snapshot.gyp:snapshot',
'<(DEPTH)/url/url.gyp:url_lib',
- '<(DEPTH)/v8/tools/gyp/v8.gyp:v8',
+ '<(DEPTH)/v8/src/v8.gyp:v8',
],
'external_xwalk_application_common_lib_dependencies_removals': [
'../../content/content.gyp:content',
'../../ipc/ipc.gyp:ipc',
'../../url/url.gyp:url_lib',
- '../../v8/tools/gyp/v8.gyp:v8',
+ '../../v8/src/v8.gyp:v8',
'../../third_party/WebKit/public/blink.gyp:blink',
],
Name: chromium-ewk
Description: EWK API based on chromium-efl engine
-Version: 51.2704.0.17-1
+Version: 53.2785.0.36-1
Requires: chromium-efl
Libs: -L${libdir} -lchromium-ewk
Cflags: -I${includedir}/chromium-ewk
#include "base/callback.h"
#include "base/macros.h"
-#include "base/memory/scoped_ptr.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"
std::string title_;
bool silent_;
uint64_t notificationID_;
- scoped_ptr<_Ewk_Security_Origin> origin_;
+ std::unique_ptr<_Ewk_Security_Origin> origin_;
DISALLOW_COPY_AND_ASSIGN(Ewk_Notification);
private:
Evas_Object* webview_;
- scoped_ptr<_Ewk_Security_Origin> origin_;
+ std::unique_ptr<_Ewk_Security_Origin> origin_;
base::Callback<void(blink::mojom::PermissionStatus)> callback_;
bool decided_;
mutable bool suspended_;
#include "base/callback.h"
#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
#include "browser/navigation_policy_handler_efl.h"
#include "browser/policy_response_delegate_efl.h"
#include "content/public/browser/web_contents_efl_delegate.h"
EWebView* web_view_;
scoped_refptr<PolicyResponseDelegateEfl> policy_response_delegate_;
- scoped_ptr<NavigationPolicyHandlerEfl> navigation_policy_handler_;
- scoped_ptr<_Ewk_Frame> frame_;
+ std::unique_ptr<NavigationPolicyHandlerEfl> navigation_policy_handler_;
+ std::unique_ptr<_Ewk_Frame> frame_;
content::WebContentsEflDelegate::NewWindowDecideCallback window_create_callback_;
std::string cookie_;
std::string url_;
#include <Eina.h>
#include <Evas.h>
-#include "base/memory/scoped_ptr.h"
#include "url/gurl.h"
#include "private/ewk_security_origin_private.h"
bool IsPersistent() const;
private:
- const scoped_ptr<_Ewk_Security_Origin> origin_;
+ const std::unique_ptr<_Ewk_Security_Origin> origin_;
int64_t newQuota_;
bool isPersistent_;
content::MediaStreamRequest request_;
content::MediaResponseCallback callback_;
- scoped_ptr<_Ewk_Security_Origin> origin_;
+ std::unique_ptr<_Ewk_Security_Origin> origin_;
bool decided_;
bool suspended_;
};
-#endif // ewk_user_media_private_h
\ No newline at end of file
+#endif // ewk_user_media_private_h
#include <base/bind.h>
#include <base/location.h>
-#include "base/thread_task_runner_handle.h"
+#include "base/threading/thread_task_runner_handle.h"
using namespace base;
// found in the LICENSE file.
#include "ewk_object.h"
-#include "config.h"
#include "private/ewk_object_private.h"
#include "private/ewk_private.h"
loadtype = content::NavigationController::LOAD_TYPE_DEFAULT;
break;
case EWK_HTTP_METHOD_POST:
- loadtype = content::NavigationController::LOAD_TYPE_BROWSER_INITIATED_HTTP_POST;
+ loadtype = content::NavigationController::LOAD_TYPE_HTTP_POST;
break;
default:
LOG(ERROR) << "Not supported HTTP Method.";
#include "third_party/WebKit/public/platform/URLConversion.h"
#include "third_party/WebKit/public/platform/WebURLError.h"
#include "third_party/WebKit/public/platform/WebURLRequest.h"
+#include "third_party/WebKit/public/platform/WebViewportStyle.h"
#include "third_party/WebKit/public/web/WebDataSource.h"
#include "third_party/WebKit/public/web/WebDocument.h"
#include "third_party/WebKit/public/web/WebFrame.h"
theme, encoded_bundle);
}
- render_process_observer_.reset(new RenderProcessObserverEfl(this));
- thread->AddObserver(render_process_observer_.get());
+ render_thread_observer_.reset(new RenderThreadObserverEfl(this));
+ thread->AddObserver(render_thread_observer_.get());
visited_link_slave_.reset(new visitedlink::VisitedLinkSlave());
thread->AddObserver(visited_link_slave_.get());
base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
if (cmdline->HasSwitch(switches::kEwkEnableMobileFeaturesForDesktop)) {
blink::WebSettings* settings = webview->settings();
- settings->setUseMobileViewportStyle(true);
+ settings->setViewportStyle(blink::WebViewportStyle::Mobile);
settings->setViewportMetaEnabled(true);
settings->setAutoZoomFocusedNodeToLegibleScale(true);
webview->setDefaultPageScaleLimits(minimum_page_scale_for_mobile,
#include "content/public/renderer/content_renderer_client.h"
#include "content/public/renderer/render_frame_observer.h"
#include "renderer/content_renderer_client_efl.h"
+#include "renderer/render_thread_observer_efl.h"
#include "v8/include/v8.h"
-#include "renderer/render_process_observer_efl.h"
namespace blink {
class WebView;
private:
static void ApplyCustomMobileSettings(blink::WebView*);
- scoped_ptr<WrtWidget> wrt_widget_;
- scoped_ptr<WrtUrlParseImpl> wrt_url_parser_;
- scoped_ptr<RenderProcessObserverEfl> render_process_observer_;
- scoped_ptr<visitedlink::VisitedLinkSlave> visited_link_slave_;
+ std::unique_ptr<WrtWidget> wrt_widget_;
+ std::unique_ptr<WrtUrlParseImpl> wrt_url_parser_;
+ std::unique_ptr<RenderThreadObserverEfl> render_thread_observer_;
+ std::unique_ptr<visitedlink::VisitedLinkSlave> visited_link_slave_;
bool javascript_can_open_windows_;
};
#endif
}
+void EditorClientAgent::OnDestruct() {
+ delete this;
+}
+
bool EditorClientAgent::OnMessageReceived(const IPC::Message& message) {
return false;
}
public:
EditorClientAgent(content::RenderView* render_view);
+ void OnDestruct() override;
+
// RenderView::Observer:
virtual bool OnMessageReceived(const IPC::Message& message) override;
return missing_plugin;
}
+void PluginPlaceholderEfl::OnLoadedRectUpdate(
+ const gfx::Rect& unobscured_rect,
+ content::RenderFrame::PeripheralContentStatus status) {
+ NOTIMPLEMENTED();
+}
+
blink::WebPlugin* PluginPlaceholderEfl::CreatePlugin() {
NOTIMPLEMENTED();
return nullptr;
blink::WebLocalFrame* frame,
const blink::WebPluginParams& params);
+ void OnLoadedRectUpdate(
+ const gfx::Rect& unobscured_rect,
+ content::RenderFrame::PeripheralContentStatus status) override;
+
private:
PluginPlaceholderEfl(content::RenderFrame* render_frame,
blink::WebLocalFrame* frame,
#include "printing/metafile_skia_wrapper.h"
#include "printing/pdf_metafile_skia.h"
#include "printing/units.h"
-#include "skia/ext/refptr.h"
#include "base/compiler_specific.h"
#include "skia/ext/platform_canvas.h"
#include "third_party/skia/include/core/SkCanvas.h"
bool PrintWebViewHelperEfl::PrintPagesToPdf(blink::WebFrame* frame,
int page_count, const gfx::Size& canvas_size) {
- printing::PdfMetafileSkia metafile;
+ printing::PdfMetafileSkia metafile(printing::PDF_SKIA_DOCUMENT_TYPE);
if (!metafile.Init())
return false;
printed_page_params.filename = filename_;
{
- scoped_ptr<base::SharedMemory> shared_mem(
+ std::unique_ptr<base::SharedMemory> shared_mem(
content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(
buf_size).release());
if (!shared_mem.get()) {
#define PRINT_WEB_VIEW_HELPER_H_
#include "base/files/file_path.h"
-#include "base/memory/scoped_ptr.h"
#include "common/print_pages_params.h"
#include "third_party/WebKit/public/platform/WebCanvas.h"
const gfx::Size& canvas_size, blink::WebFrame* frame, printing::PdfMetafileSkia* metafile);
bool RenderPagesForPrint(blink::WebFrame* frame);
- s
coped_ptr<PrintPagesParams> print_pages_params_;
+ s
td::unique_ptr<PrintPagesParams> print_pages_params_;
content::RenderView* view_;
base::FilePath filename_;
};
RenderFrameObserverEfl::~RenderFrameObserverEfl() {
}
+void RenderFrameObserverEfl::OnDestruct() {
+ delete this;
+}
+
bool RenderFrameObserverEfl::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(RenderFrameObserverEfl, message)
explicit RenderFrameObserverEfl(RenderFrame* render_frame);
virtual ~RenderFrameObserverEfl();
+ void OnDestruct() override;
+
// IPC::Listener implementation.
bool OnMessageReceived(const IPC::Message& message) override;
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "renderer/render_process_observer_efl.h"
+#include "renderer/render_thread_observer_efl.h"
#include "base/allocator/allocator_extension.h"
#include "base/command_line.h"
using blink::WebRuntimeFeatures;
using content::RenderThread;
-RenderProcessObserverEfl::RenderProcessObserverEfl(
+RenderThreadObserverEfl::RenderThreadObserverEfl(
ContentRendererClientEfl* content_client)
: content_client_(content_client) {
const base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
WebRuntimeFeatures::enableCSSViewModeMediaFeature(true);
}
-bool RenderProcessObserverEfl::OnControlMessageReceived(const IPC::Message& message)
+bool RenderThreadObserverEfl::OnControlMessageReceived(const IPC::Message& message)
{
bool handled = true;
- IPC_BEGIN_MESSAGE_MAP(RenderProcessObserverEfl, message)
+ IPC_BEGIN_MESSAGE_MAP(RenderThreadObserverEfl, message)
IPC_MESSAGE_HANDLER(EflViewMsg_ClearCache, OnClearCache)
IPC_MESSAGE_HANDLER(EflViewMsg_SetCache, OnSetCache)
IPC_MESSAGE_UNHANDLED(handled = false)
return handled;
}
-void RenderProcessObserverEfl::OnClearCache()
+void RenderThreadObserverEfl::OnClearCache()
{
WebCache::clear();
}
-void RenderProcessObserverEfl::OnSetCache(const CacheParamsEfl& params)
+void RenderThreadObserverEfl::OnSetCache(const CacheParamsEfl& params)
{
WebCache::setCapacities(static_cast<size_t>(params.cache_min_dead_capacity),
static_cast<size_t>(params.cache_max_dead_capacity),
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#ifndef RENDER_PROCESS_OBSERVER_EFL_H
-#define RENDER_PROCESS_OBSERVER_EFL_H
+#ifndef RENDER_THREAD_OBSERVER_EFL_H
+#define RENDER_THREAD_OBSERVER_EFL_H
#include <string>
#include "base/compiler_specific.h"
#include "common/cache_params_efl.h"
-#include "content/public/renderer/render_process_observer.h"
+#include "content/public/renderer/render_thread_observer.h"
namespace IPC {
class Message;
class ContentRendererClientEfl;
-class RenderProcessObserverEfl : public content::RenderProcessObserver {
+class RenderThreadObserverEfl : public content::RenderThreadObserver {
public:
- explicit RenderProcessObserverEfl(ContentRendererClientEfl* content_client);
+ explicit RenderThreadObserverEfl(ContentRendererClientEfl* content_client);
bool OnControlMessageReceived(const IPC::Message& message) override;
void OnClearCache();
return handled;
}
+void RenderViewObserverEfl::OnDestruct() {
+ delete this;
+}
+
void RenderViewObserverEfl::DidCreateDocumentElement(blink::WebLocalFrame* frame)
{
std::string policy;
virtual ~RenderViewObserverEfl();
bool OnMessageReceived(const IPC::Message& message) override;
+ void OnDestruct() override;
virtual void DidCreateDocumentElement(blink::WebLocalFrame* frame) override;
virtual void DidChangePageScaleFactor() override;
#include "base/command_line.h"
#include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/threading/worker_pool.h"
#include "base/threading/sequenced_worker_pool.h"
#include "content/public/browser/cookie_store_factory.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/url_constants.h"
+#include "components/network_session_configurator/switches.h"
#include "net/base/cache_type.h"
#include "net/cert/cert_verifier.h"
#include "net/dns/host_resolver.h"
it != protocol_handlers->end();
++it) {
bool set_protocol = job_factory->SetProtocolHandler(
- it->first, make_scoped_ptr(it->second.release()));
+ it->first, base::WrapUnique(it->second.release()));
DCHECK(set_protocol);
}
protocol_handlers->clear();
} // namespace
URLRequestContextGetterEfl::URLRequestContextGetterEfl(
- scoped_ptr<net::NetworkDelegate> network_delegate,
+ std::unique_ptr<net::NetworkDelegate> network_delegate,
bool ignore_certificate_errors,
const base::FilePath& base_path,
const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
new net::URLRequestContextStorage(url_request_context_.get()));
storage_->set_cookie_store(
CreateCookieStore(CookieStoreConfig()));
- storage_->set_channel_id_service(make_scoped_ptr(new net::ChannelIDService(
+ storage_->set_channel_id_service(base::WrapUnique(new net::ChannelIDService(
new net::DefaultChannelIDStore(NULL),
base::WorkerPool::GetTaskRunner(true))));
storage_->set_http_user_agent_settings(
- make_scoped_ptr(new HttpUserAgentSettingsEfl()));
+ base::WrapUnique(new HttpUserAgentSettingsEfl()));
- scoped_ptr<net::HostResolver> host_resolver(
+ std::unique_ptr<net::HostResolver> host_resolver(
net::HostResolver::CreateDefaultResolver(
url_request_context_->net_log()));
storage_->set_cert_verifier(net::CertVerifier::CreateDefault());
storage_->set_transport_security_state(
- make_scoped_ptr(new net::TransportSecurityState));
+ base::WrapUnique(new net::TransportSecurityState));
// TODO(jam): use v8 if possible, look at chrome code.
storage_->set_proxy_service(
storage_->set_http_auth_handler_factory(
net::HttpAuthHandlerFactory::CreateDefault(host_resolver.get()));
storage_->set_http_server_properties(
- scoped_ptr<net::HttpServerProperties>(
+ std::unique_ptr<net::HttpServerProperties>(
new net::HttpServerPropertiesImpl()));
net::HttpCache::DefaultBackend* main_backend = NULL;
network_session_params.testing_fixed_https_port = value;
}
if (command_line.HasSwitch(switches::kHostResolverRules)) {
- scoped_ptr<net::MappedHostResolver> mapped_host_resolver(
+ std::unique_ptr<net::MappedHostResolver> mapped_host_resolver(
new net::MappedHostResolver(std::move(host_resolver)));
mapped_host_resolver->SetRulesFromString(
command_line.GetSwitchValueASCII(switches::kHostResolverRules));
new net::HttpNetworkSession(network_session_params));
net::HttpCache* main_cache = new net::HttpCache(
- http_network_session_.get(), make_scoped_ptr(main_backend), true);
- storage_->set_http_transaction_factory(make_scoped_ptr(main_cache));
+ http_network_session_.get(), base::WrapUnique(main_backend), true);
+ storage_->set_http_transaction_factory(base::WrapUnique(main_cache));
- scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
+ std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory(
new net::URLRequestJobFactoryImpl());
// Keep ProtocolHandlers added in sync with
// ShellContentBrowserClient::IsHandledURL().
InstallProtocolHandlers(job_factory.get(), &protocol_handlers_);
bool set_protocol = job_factory->SetProtocolHandler(
- url::kDataScheme, make_scoped_ptr(new net::DataProtocolHandler));
+ url::kDataScheme, base::WrapUnique(new net::DataProtocolHandler));
DCHECK(set_protocol);
set_protocol = job_factory->SetProtocolHandler(
url::kFileScheme,
- make_scoped_ptr(new net::FileProtocolHandler(
+ base::WrapUnique(new net::FileProtocolHandler(
BrowserThread::GetBlockingPool()->
GetTaskRunnerWithShutdownBehavior(
base::SequencedWorkerPool::SKIP_ON_SHUTDOWN))));
DCHECK(set_protocol);
// Set up interceptors in the reverse order.
- scoped_ptr<net::URLRequestJobFactory> top_job_factory =
+ std::unique_ptr<net::URLRequestJobFactory> top_job_factory =
std::move(job_factory);
for (URLRequestInterceptorScopedVector::reverse_iterator i =
request_interceptors_.rbegin();
i != request_interceptors_.rend();
++i) {
top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
- std::move(top_job_factory), make_scoped_ptr(*i)));
+ std::move(top_job_factory), base::WrapUnique(*i)));
}
request_interceptors_.weak_clear();
- storage_->set_job_factory(make_scoped_ptr(top_job_factory.release()));
+ storage_->set_job_factory(base::WrapUnique(top_job_factory.release()));
}
return url_request_context_.get();
// 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_ptr<net::CookieMonster> cookie_monster(
+ std::unique_ptr<net::CookieMonster> cookie_monster(
new net::CookieMonster(persistent_store.get(), NULL));
storage_->set_cookie_store(std::move(cookie_monster));
#ifndef _URL_REQUEST_CONTEXT_GETTER_EFL_H_
#define _URL_REQUEST_CONTEXT_GETTER_EFL_H_
-#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"
class URLRequestContextGetterEfl : public net::URLRequestContextGetter {
public:
- URLRequestContextGetterEfl(scoped_ptr<net::NetworkDelegate> network_delegate = scoped_ptr<net::NetworkDelegate>(),
+ URLRequestContextGetterEfl(std::unique_ptr<net::NetworkDelegate> network_delegate = std::unique_ptr<net::NetworkDelegate>(),
bool ignore_certificate_errors = false,
const base::FilePath& base_path = base::FilePath(),
const scoped_refptr<base::SingleThreadTaskRunner> &io_task_runner = BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
net::NetLog* net_log_;
base::FilePath cookie_store_path_;
- scoped_ptr<net::CookieStore> cookie_store_;
+ std::unique_ptr<net::CookieStore> cookie_store_;
- scoped_ptr<net::HttpNetworkSession> http_network_session_;
- scoped_ptr<net::ProxyConfigService> proxy_config_service_;
- scoped_ptr<net::NetworkDelegate> network_delegate_;
- scoped_ptr<net::URLRequestContextStorage> storage_;
- scoped_ptr<net::URLRequestContext> url_request_context_;
+ std::unique_ptr<net::HttpNetworkSession> http_network_session_;
+ std::unique_ptr<net::ProxyConfigService> proxy_config_service_;
+ std::unique_ptr<net::NetworkDelegate> network_delegate_;
+ std::unique_ptr<net::URLRequestContextStorage> storage_;
+ std::unique_ptr<net::URLRequestContext> url_request_context_;
ProtocolHandlerMap protocol_handlers_;
URLRequestInterceptorScopedVector request_interceptors_;
base::WeakPtrFactory<URLRequestContextGetterEfl> weak_ptr_factory_;
}
else {
callback.Run(MediaStreamDevices(), MEDIA_DEVICE_NOT_SUPPORTED,
- scoped_ptr<MediaStreamUI>());
+ std::unique_ptr<MediaStreamUI>());
}
#else
devices.push_back(MediaStreamDevice(request.video_type, "/dev/video0", "1"));
#endif
}
- callback.Run(devices, MEDIA_DEVICE_OK,scoped_ptr<MediaStreamUI>());
+ callback.Run(devices, MEDIA_DEVICE_OK,std::unique_ptr<MediaStreamUI>());
}
void WebContentsDelegateEfl::RequestMediaAccessDeny(
const MediaResponseCallback& callback) {
LOG(ERROR) << __FUNCTION__ << " Decline request with empty list";
callback.Run(MediaStreamDevices(), MEDIA_DEVICE_NOT_SUPPORTED,
- scoped_ptr<MediaStreamUI>());
+ std::unique_ptr<MediaStreamUI>());
}
bool WebContentsDelegateEfl::CheckMediaAccessPermission(
WebContents* web_contents,
const MediaStreamRequest& request,
const MediaResponseCallback& callback) {
- scoped_ptr<_Ewk_User_Media_Permission_Request> media_permission_request(
+ std::unique_ptr<_Ewk_User_Media_Permission_Request> media_permission_request(
new _Ewk_User_Media_Permission_Request(this, request, callback));
Eina_Bool callback_result = EINA_FALSE;
ignore_result(media_permission_request.release());
else if (!media_permission_request->IsDecided()) {
callback.Run(MediaStreamDevices(), MEDIA_DEVICE_NOT_SUPPORTED,
- scoped_ptr<MediaStreamUI>());
+ std::unique_ptr<MediaStreamUI>());
}
}
#endif
}
void WebContentsDelegateEfl::OnWrtPluginMessage(const Ewk_Wrt_Message_Data& data) {
- scoped_ptr<Ewk_Wrt_Message_Data> p(new Ewk_Wrt_Message_Data);
+ std::unique_ptr<Ewk_Wrt_Message_Data> p(new Ewk_Wrt_Message_Data);
p->type = data.type;
p->value = data.value;
p->id = data.id;
NOTREACHED() << "couldn't map";
return;
}
- scoped_ptr<printing::PdfMetafileSkia> metafile(new printing::PdfMetafileSkia);
+
+ std::unique_ptr<printing::PdfMetafileSkia> metafile
+ (new printing::PdfMetafileSkia(printing::PDF_SKIA_DOCUMENT_TYPE));
if (!metafile->InitFromData(shared_buf.memory(), params.data_size)) {
NOTREACHED() << "Invalid metafile header";
return;
const string16& message,
int32_t line_no,
const string16& source_id) {
- scoped_ptr<_Ewk_Console_Message> console_message(new _Ewk_Console_Message(level,
+ std::unique_ptr<_Ewk_Console_Message> console_message(new _Ewk_Console_Message(level,
UTF16ToUTF8(message).c_str(),
line_no,
UTF16ToUTF8(source_id).c_str()));
return true;
}
-void WebContentsDelegateEfl::RunFileChooser(WebContents* web_contents, const FileChooserParams& params) {
+void WebContentsDelegateEfl::RunFileChooser(RenderFrameHost* render_frame_host, const FileChooserParams& params) {
web_view_->ShowFileChooser(params);
}
#include <deque>
-#include "base/memory/scoped_ptr.h"
#include "content/public/browser/browser_context.h"
#include "browser/javascript_dialog_manager_efl.h"
#include "browser_context_efl.h"
const base::string16& message,
int32_t line_no,
const base::string16& source_id) override;
- void RunFileChooser(WebContents* web_contents,
+ void RunFileChooser(content::RenderFrameHost* render_frame_host,
const FileChooserParams& params) override;
ColorChooser* OpenColorChooser(WebContents* web_contents, SkColor color,
const std::vector<ColorSuggestion>& suggestions) override;
Ewk_CSP_Header_Type header_type;
};
- scoped_ptr<ContentSecurityPolicy> pending_content_security_policy_;
+ std::unique_ptr<ContentSecurityPolicy> pending_content_security_policy_;
bool document_created_;
JavaScriptDialogManagerEfl* dialog_manager_;
- scoped_ptr<FaviconDownloader> favicon_downloader_;
+ std::unique_ptr<FaviconDownloader> favicon_downloader_;
base::WeakPtrFactory<WebContentsDelegateEfl> weak_ptr_factory_;
- scoped_ptr<_Ewk_Certificate_Policy_Decision> certificate_policy_decision_;
+ std::unique_ptr<_Ewk_Certificate_Policy_Decision> certificate_policy_decision_;
DISALLOW_COPY_AND_ASSIGN(WebContentsDelegateEfl);
};
content::WebContentsEflDelegate::NewWindowDecideCallback callback,
const GURL& target_url) {
// this method is called ONLY when creating new window - no matter what type
- scoped_ptr<_Ewk_Policy_Decision> pd(
+ std::unique_ptr<_Ewk_Policy_Decision> pd(
new _Ewk_Policy_Decision(web_view_, callback));
pd->ParseUrl(target_url);
web_view_->SmartCallback<EWebViewCallbacks::NewWindowPolicyDecision>().call(pd.get());
// TODO(z.kostrzewa) I would prefer not make it a singleton, check out
// if it can't be a member of ContentMainDelegateEfl (but keep the static
// getter, maybe?).
-base::LazyInstance<scoped_ptr<WrtWidgetHost> > g_wrt_widget_host =
+base::LazyInstance<std::unique_ptr<WrtWidgetHost> > g_wrt_widget_host =
LAZY_INSTANCE_INITIALIZER;
bool SendToAllRenderers(IPC::Message* message) {
// TODO(z.kostrzewa) Why it can't be implemented as IPC::ChannelProxy::MessageFilter (?)
// Tried that and it seems that Observer starts receiving messages earlier than
// MessageFilter what is crucial for message that sets widget handle
-class WrtRenderThreadObserver : public content::RenderProcessObserver {
+class WrtRenderThreadObserver : public content::RenderThreadObserver {
public:
explicit WrtRenderThreadObserver(WrtWidget* wrt_widget)
: wrt_widget_(wrt_widget),
delete observer_;
}
-content::RenderProcessObserver* WrtWidget::GetObserver() {
+content::RenderThreadObserver* WrtWidget::GetObserver() {
return observer_;
}
#include <string>
-#include "content/public/renderer/render_process_observer.h"
+#include "content/public/renderer/render_thread_observer.h"
#include "url/gurl.h"
#include "v8/include/v8.h"
WrtWidget();
~WrtWidget();
- content::RenderProcessObserver* GetObserver();
+ content::RenderThreadObserver* GetObserver();
void SetWidgetInfo(const std::string& tizen_id,
double scaleFactor,
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="51.2704.0.17">
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="53.2785.0.36">
<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="51.2704.0.17">
+<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.chromium-efl" version="53.2785.0.36">
<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="51.2704.0.17"
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="53.2785.0.36"
<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="51.2704.0.17">
+<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.chromium-efl" version="53.2785.0.36">
<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="51.2704.0.17">
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="53.2785.0.36">
<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>
'resources/ewk_context/injected_bundle/chromium/bundle_sample.cc',
],
'dependencies': [
- '<(DEPTH)/v8/tools/gyp/v8.gyp:v8',
+ '<(DEPTH)/v8/src/v8.gyp:v8',
],
'include_dirs': [
'.',
%define _binary_payload w3.gzdio
Name: chromium-efl-libs
-%define ChromiumVersion 51.2704.0
-%define Week 17
+%define ChromiumVersion 53.2785.0
+%define Week 36
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 51.2704.0
-%define Week 17
+%define ChromiumVersion 53.2785.0
+%define Week 36
Version: %{ChromiumVersion}.%{Week}
Release: 1
# The 'Group' should be specified as one of the following valid group list.
BuildRequires: pkgconfig(libdrm)
BuildRequires: pkgconfig(libexif)
BuildRequires: pkgconfig(libffi)
-BuildRequires: pkgconfig(libpci)
BuildRequires: pkgconfig(libpng)
BuildRequires: pkgconfig(libpulse)
BuildRequires: pkgconfig(libtbm)
Chromium EFL unit test utilities
%endif
-%if 0%{?build_chromedriver}
-%package -n chromedriver
-Summary: Selenium WebDriver for t-browser
-Group: Development/Libraries
-%description -n chromedriver
-Selenium WebDriver for t-browser
-%endif
-
# The macros '%TZ_' are valid from tizen v3.0
%if "%{chromium_efl_tizen_version}" >= "3.0"
%define _manifestdir %TZ_SYS_RW_PACKAGES
%if 0%{?build_ewk_unittests}
ewk_unittests \
%endif
-%if 0%{?build_chromedriver}
- chromedriver \
-%endif
%if 0%{?build_xwalk}
xwalk xwalk_application_tools \
%endif
install -d "%{buildroot}%{CHROMIUM_EXE_DIR}"
install -d "%{buildroot}%{CHROMIUM_EXE_DIR}/locales"
install -d "%{buildroot}%{CHROMIUM_DATA_DIR}"/themes
-%if 0%{?build_chromedriver}
-install -d "%{buildroot}"/usr/apps/com.samsung.chromedriver/bin
-%endif
cp -r "%{OUTPUT_FOLDER}/locale" "%{buildroot}/%{CHROMIUM_LOCALE_DIR}"
install -m 0644 tizen_src/ewk/efl_integration/public/*.h "%{buildroot}"%{_includedir}/chromium-ewk/
install -m 0644 v8/include/*.h "%{buildroot}"%{_includedir}/v8/
-%if 0%{?build_chromedriver}
-install -m 0755 "%{OUTPUT_FOLDER}"/chromedriver "%{buildroot}"/usr/apps/com.samsung.chromedriver/bin
-install -m 0755 tizen_src/scripts/start-chrome-driver.sh "%{buildroot}"/%{_bindir}
-%endif
-
%if 0%{?_enable_content_shell}
install -m 0755 "%{OUTPUT_FOLDER}"/content_shell "%{buildroot}%{CHROMIUM_EXE_DIR}"/content_shell
sed 's#@binary@#%{CHROMIUM_EXE_DIR}/content_shell#' %{SOURCE1} > "%{buildroot}"%{_bindir}/content_shell
/opt/usr/resources/*
%endif
-%if 0%{?build_chromedriver}
-%files -n chromedriver
-/usr/bin/start-chrome-driver.sh
-/usr/apps/com.samsung.chromedriver
-%endif
-
%if 0%{?build_xwalk}
%files -n crosswalk
%manifest %{XWALK_GEN}/crosswalk.manifest
%define _binary_payload w3.gzdio
Name: crosswalk-bin
-Version: 15.51.2704.0
+Version: 15.53.2785.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>51.2704.0.17</Version>
+ <Version>53.2785.0.36</Version>
<Type>C++App</Type>
<Descriptions>
<Description Locale="eng-PH"/>
+++ /dev/null
-#!/bin/bash
-
-echo "Starting chromedriver for chromium M42 for Tizen 3.0"
-
-/usr/apps/com.samsung.chromedriver/bin/chromedriver --whitelisted-ips
{
'variables': {
'variables': {
- 'use_gstreamer_fft': 1,
+ # [M53_2785] Temporary disabling the 'use_gstreamer_fft' flag for switching
+ # to new chromium
+ # It will be fixed by multimedia team
+ # FIXME:
+ 'use_gstreamer_fft': 0,
},
'use_aura%': 0,
'use_efl%' : 1,
'use_default_render_theme%': 1,
+ # Whether or not we use external popup menu.
+ 'use_external_popup_menu%': 1,
+
'ewk_bringup%': 1,
'wayland_bringup%': 0,
projects / platform / framework / web / chromium-efl.git / commitdiff