# SVN revision while Blink is still in SVN.
blink_upstream_rev = '191638' #TODO(TK) : need to update revision number
-efl_integration_branch = 'origin/beta/m42_2311_t'
+efl_integration_branch = 'origin/dev/m44_2403'
ct_git = 'ssh://165.213.202.130:29418/webplatform'
ozone_wayland_git = 'https://github.com/01org'
-Chromium upsteam version: 42.0.2311.0
+Chromium upsteam version: 44.0.2403.0
[profile.tizenmb_v2.4]
obs = obs.tizenmb
# The order is IMPORTANT!
-repos = repo.devel-gcc49-base, repo.tizenmb_base_v2.4_obs
+repos = repo.tizenmb_supplement_v2.4, repo.devel_gcc49_base_standard, repo.spin_2.4_mobile_target_tm1
buildroot = ~/GBS-ROOT-2.4-DEV
-[repo.devel-gcc49-base]
-url = http://168.219.209.55/download/live/devel:/gcc49:/Base/standard/
+[repo.spin_2.4_mobile_target_tm1]
+url = http://168.219.209.55/download/snapshots/2.4-mobile/common/latest/repos/target-TM1/packages/
-[repo.tizenmb_base_v2.4_obs]
-url = http://168.219.209.55/download/snapshots/2.4-mobile/common/latest/repos/target/packages
+[repo.devel_gcc49_base_standard]
+url = http://168.219.209.55/download/snapshots/2.4-base/common/latest/repos/standard/packages/
+
+[repo.tizenmb_supplement_v2.4]
+url = http://10.251.52.177/tizenrepo/eur-open/supplement_mobile_v2.4/
###############################################
#
[profile.tizen_emulator_v2.4]
obs = obs.tizenmb
# The order is IMPORTANT!
-repos = repo.tizen_emulator_base_v2.4_obs
+repos = repo.spin_2.4_mobile_emulator, repo.devel_gcc49_base_emulator
buildroot = ~/GBS-ROOT-2.4-DEV
-[repo.tizen_emulator_base_v2.4_obs]
-url = http://168.219.209.55/download/snapshots/2.4-mobile/common/latest/repos/emulator/packages
+[repo.spin_2.4_mobile_emulator]
+url = http://168.219.209.55/download/snapshots/2.4-mobile/common/latest/repos/emulator/packages/
+
+[repo.devel_gcc49_base_emulator]
+url = http://168.219.209.55/download/live/devel:/gcc49:/Base/emulator/
###############################################
#
-Duse_cairo=0
-Duse_openssl=1
-Duse_openssl_certs=1
+ -Duse_nss_certs=0
-Dtizen_multimedia_eme_support=0
-Denable_plugins=1
-Denable_extensions=1
-Dbuilding_for_tizen_mobile=0
-Dbuilding_for_tizen_tv=0
-Dclang=${USE_CLANG}
- -Dtizen_multimedia_support=1
-Dwerror=
-Duse_wayland=0
"
+ # [M44_2403] Temporary disabling the multimedia flag for switching to new chromium
+ # FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14037
+ ADDITIONAL_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
+ "
}
add_arm_flags() {
fi
if [ "$tizen_version" == "3.0" ]; then
- COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=1
+ # [M44_2403] Temporary disabling the multimedia flag for switching to new chromium
+ # FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14037
+ COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
"
elif [ "$tizen_version" == "2.4" -a "$target" == "tv" ]; then
- COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=1
+ # [M44_2403] Temporary disabling the multimedia flag for switching to new chromium
+ # FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14037
+ COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
"
else
COMMON_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
# Unfortunately the gbs root doesn't contain everything chromium needs.
SYSTEM_DEPS="-Duse_system_expat=1
-Duse_system_flac=1
- -Duse_system_icu=1
-Duse_system_libjpeg=0
-Duse_system_libpng=1
-Duse_system_libxml=1
-Duse_system_speex=1
-Duse_system_zlib=1
"
+
+ # [M44_2403] Temporary changing which uses the chromium 'ICU' instead of the system 'ICU'
+ # for switching to new chromium
+ # FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=13290
+ SYSTEM_DEPS="-Duse_system_icu=0
+ "
+
if [ "$target" == "mobile" ]; then
SYSTEM_DEPS+="-Duse_system_bzip2=1
-Duse_system_libexif=1
--- /dev/null
+diff --git a/third_party/angle/src/libGLESv2.gypi b/src/libGLESv2.gypi
+index bc021c5..29c93fc 100644
+--- a/third_party/angle/src/libGLESv2.gypi
++++ b/third_party/angle/src/libGLESv2.gypi
+@@ -744,7 +744,7 @@
+ {
+ 'msvs_enable_winphone' : '1',
+ }],
+- ['OS=="linux"',
++ ['OS=="linux" and use_wayland==0',
+ {
+ 'link_settings': {
+ 'ldflags': [
}
}
-void JavaScriptDialogManagerEfl::WebContentsDestroyed(
+void JavaScriptDialogManagerEfl::ResetDialogState(
content::WebContents* web_contents) {
- CancelActiveAndPendingDialogs(web_contents);
+ NOTIMPLEMENTED();
}
} // namespace content
const base::string16* prompt_override) override;
void CancelActiveAndPendingDialogs(
content::WebContents* web_contents) override;
- void WebContentsDestroyed(
+ void ResetDialogState(
content::WebContents* web_contents) override;
private:
delegate_->GetTextureFromMailbox(mailbox, size);
}
-void ContextFactoryEfl::CreateOutputSurface(
- base::WeakPtr<Compositor> compositor,
- bool software_fallback) {
+void ContextFactoryEfl::CreateOutputSurface(base::WeakPtr<Compositor> compositor) {
blink::WebGraphicsContext3D::Attributes attrs;
attrs.depth = false;
attrs.stencil = false;
if (gpu_channel_host.get() && !gpu_channel_host->IsLost()) {
context_provider = content::ContextProviderCommandBuffer::Create(
CreateGpuProcessViewContext(gpu_channel_host, attrs, 0),
- "BrowserCompositor");
+ content::BROWSER_COMPOSITOR_ONSCREEN_CONTEXT);
}
if (!context_provider.get()) {
LOG(ERROR) << "Failed to create 3D context for compositor.";
#endif
}
-scoped_refptr<Reflector> ContextFactoryEfl::CreateReflector(
+scoped_ptr<Reflector> ContextFactoryEfl::CreateReflector(
Compositor* mirrored_compositor,
Layer* mirroring_layer) {
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14038
return new Reflector();
+#else
+ // It should be removed after resolving this issue.
+ return NULL;
+#endif
}
-void ContextFactoryEfl::RemoveReflector(scoped_refptr<Reflector> reflector) {
+void ContextFactoryEfl::RemoveReflector(Reflector* reflector) {
}
void ContextFactoryEfl::OnLostMainThreadSharedContextInsideCallback() {
if (gpu_channel_host.get() && !gpu_channel_host->IsLost()) {
shared_main_thread_contexts_ = content::ContextProviderCommandBuffer::Create(
CreateGpuProcessViewContext(gpu_channel_host, attrs, 0),
- "Offscreen-MainThread");
+ content::BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
}
if (!shared_main_thread_contexts_->BindToCurrentThread())
return false;
}
+uint32 ContextFactoryEfl::GetImageTextureTarget() {
+ return GL_TEXTURE_2D;
+}
+
cc::SharedBitmapManager* ContextFactoryEfl::GetSharedBitmapManager() {
return content::HostSharedBitmapManager::current();
}
return content::BrowserGpuMemoryBufferManager::current();
}
-base::MessageLoopProxy* ContextFactoryEfl::GetCompositorMessageLoop() {
- return NULL;
+cc::TaskGraphRunner* ContextFactoryEfl::GetTaskGraphRunner() {
+ NOTIMPLEMENTED();
}
scoped_ptr<cc::SurfaceIdAllocator>
public:
ContextFactoryEfl(content::ContextFactoryDelegate* delegate, int surface_id);
- void CreateOutputSurface(base::WeakPtr<Compositor> compositor,
- bool software_fallback) override;
+ void CreateOutputSurface(base::WeakPtr<Compositor> compositor) override;
- scoped_refptr<Reflector> CreateReflector(Compositor* mirrored_compositor,
- Layer* mirroring_layer) override;
+ scoped_ptr<Reflector> CreateReflector(Compositor* mirrored_compositor,
+ Layer* mirroring_layer) override;
- void RemoveReflector(scoped_refptr<Reflector> reflector) override;
+ void RemoveReflector(Reflector* reflector) override;
scoped_refptr<cc::ContextProvider> SharedMainThreadContextProvider() override;
bool DoesCreateTestContexts() override;
+ uint32 GetImageTextureTarget() override;
+
cc::SharedBitmapManager* GetSharedBitmapManager() override;
gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override;
- base::MessageLoopProxy* GetCompositorMessageLoop() override;
+ cc::TaskGraphRunner* GetTaskGraphRunner() override;
scoped_ptr<cc::SurfaceIdAllocator> CreateSurfaceIdAllocator() override;
#include "third_party/WebKit/public/web/WebTouchPoint.h"
#include "ui/base/clipboard/clipboard_helper_efl.h"
#include "ui/base/layout.h"
+#include "ui/events/blink/blink_event_util.h"
#include "ui/events/event_switches.h"
#include "ui/events/event_utils.h"
#define private public
context_factory_ = new ui::ContextFactoryEfl(this, host_->surface_id());
- bool gpu_thread_disabled = false;
-
-#if defined(TIZEN_DISABLE_GPU_THREAD)
- gpu_thread_disabled = GpuDataManagerImpl::GetInstance()->GpuThreadDisabled();
-#endif
-
compositor_ = new ui::Compositor(GetNativeViewId(),
- context_factory_,
- base::ThreadTaskRunnerHandle::Get(),
- gpu_thread_disabled);
+ context_factory_,
+ base::ThreadTaskRunnerHandle::Get());
#if defined(TIZEN_DISABLE_GPU_THREAD)
if (gpu_thread_disabled) {
evas_object_focus_set(content_image_, EINA_TRUE);
}
-void RenderWidgetHostViewEfl::Blur() {
- elm_object_focus_set(content_image_elm_host_, EINA_FALSE);
- evas_object_focus_set(content_image_, EINA_FALSE);
-}
-
bool RenderWidgetHostViewEfl::HasFocus() const {
return evas_object_focus_get(content_image_);
}
result_rect.size(),
result_rect,
video_frame->coded_size(),
- region_in_frame,
true,
true));
yuv_readback_pipeline = rwhvefl->yuv_readback_pipeline_.get();
texture_mailbox.mailbox(),
texture_mailbox.sync_point(),
video_frame,
+ video_frame->visible_rect().origin(),
finished_callback);
}
void RenderWidgetHostViewEfl::OnHostFocusOut(
void* data, Evas_Object*, void*) {
RenderWidgetHostViewEfl* thiz = static_cast<RenderWidgetHostViewEfl*>(data);
- thiz->Blur();
+ thiz->host_->Blur();
}
void RenderWidgetHostViewEfl::OnMouseDown(
return;
}
- blink::WebTouchEvent touch_event = CreateWebTouchEventFromMotionEvent(
+ blink::WebTouchEvent touch_event = ui::CreateWebTouchEventFromMotionEvent(
pointer_state_, event->may_cause_scrolling());
pointer_state_.CleanupRemovedTouchPoints(*event);
- // Forward the touch event only if a touch point was updated, and there's a
- // touch-event handler in the page, and no other touch-event is in the queue.
- // It is important to always consume the event if there is a touch-event
- // handler in the page, or some touch-event is already in the queue, even if
- // no point has been updated, to make sure that this event does not get
- // processed by the gesture recognizer before the events in the queue.
- if (host_->ShouldForwardTouchEvent()) {
- event->StopPropagation();
- }
-
- bool forwarded = false;
- if (host_->ShouldForwardTouchEvent()) {
- forwarded = true;
- host_->ForwardTouchEventWithLatencyInfo(touch_event, *event->latency());
- }
-
- // If we forward it to the renderer than either blink handles it or we will
- // have a second round with it in ProcessAckedTouchEvent.
- if (forwarded)
- return;
+ event->StopPropagation();
+ host_->ForwardTouchEventWithLatencyInfo(touch_event, *event->latency());
scoped_ptr<ui::GestureRecognizer::Gestures> gestures(
gesture_recognizer_->AckSyncTouchEvent(event->unique_event_id(), ui::ER_UNHANDLED, this));
bool LockMouse() override;
void UnlockMouse() override;
void Focus() override;
- void Blur() override;
bool HasFocus() const override;
void MovePluginContainer(const WebPluginGeometry&);
void MovePluginWindows(
WebContents* web_contents,
blink::WebScreenOrientationLockType lock_orientation) {
content::WebContentsDelegate* delegate = web_contents->GetDelegate();
-
- if (delegate)
- delegate->OrientationLock(lock_orientation);
}
bool ScreenOrientationDelegateEfl::ScreenOrientationProviderSupported() {
void ScreenOrientationDelegateEfl::Unlock(WebContents* web_contents) {
content::WebContentsDelegate* delegate = web_contents->GetDelegate();
-
- if (delegate)
- delegate->OrientationUnlock();
}
} // namespace content
if (process_handle != base::kNullProcessHandle) {
RecordAction(
base::UserMetricsAction("Terminate_ProcessMismatch_CreateNewWindow"));
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14039
base::KillProcess(process_handle, RESULT_CODE_KILLED, false);
+#endif
}
return;
}
params.screen_info = screen_info;
params.new_size =
gfx::Size(screen_info.rect.width, screen_info.rect.height);
- params.is_fullscreen = contents_impl.IsFullscreenForCurrentTab();
+ params.is_fullscreen_granted = contents_impl.IsFullscreenForCurrentTab();
rwh->Send(new ViewMsg_Resize(rwh->GetRoutingID(), params));
rwhv->UpdateScreenInfo(rwhv->GetNativeView());
namespace content {
struct GpuChildThreadEfl : public content::GpuChildThread {
- explicit GpuChildThreadEfl(const std::string& channel_id)
- : GpuChildThread(channel_id) { }
+ explicit GpuChildThreadEfl(const content::InProcessChildThreadParams& params)
+ : GpuChildThread(params) { }
bool OnControlMessageReceived(const IPC::Message& msg) override {
bool handled = true;
struct InProcessGpuThreadEfl : public content::InProcessGpuThread {
- explicit InProcessGpuThreadEfl(const std::string& channel_id)
- : InProcessGpuThread(channel_id) { }
+ explicit InProcessGpuThreadEfl(const content::InProcessChildThreadParams& params)
+ : InProcessGpuThread(params) { }
void Init() override {
gpu_process_ = new content::GpuProcess();
// The process object takes ownership of the thread object, so do not
// save and delete the pointer.
- gpu_process_->set_main_thread(new GpuChildThreadEfl(channel_id_));
+ gpu_process_->set_main_thread(new GpuChildThreadEfl(params_));
}
};
-base::Thread* CreateInProcessGpuThread(const std::string& channel_id) {
- return new InProcessGpuThreadEfl(channel_id);
+base::Thread* CreateInProcessGpuThread(const content::InProcessChildThreadParams& params) {
+ return new InProcessGpuThreadEfl(params);
}
} // namespace content
namespace content {
-static void LogMediaSourceError(
- const scoped_refptr<media::MediaLog>& media_log,
- const std::string& error) {
- media_log->AddEvent(media_log->CreateMediaSourceErrorEvent(error));
-}
-
MediaSourceDelegateEfl::MediaSourceDelegateEfl(
RendererDemuxerEfl* demuxer_client,
int demuxer_client_id,
media::BindToCurrentLoop(
base::Bind(&MediaSourceDelegateEfl::OnEncryptedMediaInitData,
main_weak_this_)),
- base::Bind(&LogMediaSourceError, media_log_), media_log_, false));
+ base::Bind(&media::MediaLog::AddLogEvent, media_log_, false));
media_task_runner_->PostTask(FROM_HERE,
base::Bind(&MediaSourceDelegateEfl::InitializeDemuxer,
}
void MediaSourceDelegateEfl::OnEncryptedMediaInitData (
- const std::string& type,
+ media::EmeInitDataType /* init_data_type */,
const std::vector<uint8>& init_data) {
DCHECK(main_loop_->BelongsToCurrentThread());
if (emedia_init_data_cb_.is_null()) {
if (media_source_opened_cb_.is_null())
return;
media_source_opened_cb_.Run(new media::WebMediaSourceImpl(
- chunk_demuxer_.get(), base::Bind(&LogMediaSourceError, media_log_)));
+ chunk_demuxer_.get(), base::Bind(&media::MediaLog::AddLogEvent, media_log_)));
}
void MediaSourceDelegateEfl::OnDemuxerError(
void OnDemuxerSeekDone(media::PipelineStatus status);
private:
- void OnEncryptedMediaInitData(const std::string& type,
+ void OnEncryptedMediaInitData(media::EmeInitDataType init_data_type,
const std::vector<uint8>& init_data);
void OnDemuxerOpened();
void InitializeDemuxer();
#include "base/message_loop/message_loop.h"
#include "base/memory/shared_memory.h"
#include "cc/layers/video_frame_provider_client_impl.h"
+#include "content/common/media/tizen/media_player_messages_enums_tizen.h"
#include "content/renderer/media/efl/media_source_delegate_efl.h"
#include "content/renderer/media/efl/renderer_media_player_manager_efl.h"
#include "media/base/efl/media_player_efl.h"
+#include "media/blink/skcanvas_video_renderer.h"
#include "media/blink/video_frame_compositor.h"
-#include "media/filters/skcanvas_video_renderer.h"
#include "third_party/WebKit/public/platform/WebMediaPlayer.h"
#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
static void OnNewWindow(void* data, Evas_Object*, void*) {
Shell* shell = static_cast<Shell::Impl*>(data)->shell_;
+ gfx::Size initial_size = Shell::GetShellDefaultSize();
Shell::CreateNewWindow(shell->web_contents()->GetBrowserContext(),
GURL("https://www.google.com"),
NULL,
- gfx::Size(kDefaultTestWindowWidthDip,
- kDefaultTestWindowHeightDip));
+ initial_size);
}
static void OnForward(void* data, Evas_Object*, void*) {
Evas_Object* win = efl::WindowFactory::GetHostWindow(web_contents_.get());
evas_object_smart_callback_add(win, "delete,request",
OnShellWindowDelRequest, this);
- evas_object_resize(win, kDefaultTestWindowWidthDip,
- kDefaultTestWindowHeightDip);
+ gfx::Size initial_size = Shell::GetShellDefaultSize();
+ evas_object_resize(win, initial_size.width(), initial_size.height());
evas_object_show(win);
window_ = win;
impl_ = new Impl(this, static_cast<Evas_Object*>(window_));
cmdline.AppendSwitch(switches::kUIDisableThreadedCompositing);
cmdline.AppendSwitch(switches::kEnableDelegatedRenderer);
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14040
#if defined(OS_TIZEN)
cmdline.AppendSwitch(cc::switches::kEnableTileCompression);
cmdline.AppendSwitchASCII(cc::switches::kTileCompressionThreshold, "-1");
cmdline.HasSwitch(cc::switches::kEnableTileCompression))
cmdline.AppendSwitch(switches::kDisableGpuRasterization);
#endif
+#endif // EWK_BRINGUP
#if defined(OS_TIZEN_TV)
cmdline.AppendSwitchASCII(switches::kAcceleratedCanvas2dMSAASampleCount, "4");
['_target_name=="webcore_rendering"', {
'sources/': [
- [ 'exclude', 'layout/LayoutThemeChromiumLinux\\.cpp$' ],
+ [ 'exclude', 'layout/LayoutThemeLinux\\.cpp$' ],
],
'sources': [
'rendering/RenderThemeChromiumTizen.cpp',
String RenderThemeChromiumTizen::extraDefaultStyleSheet()
{
- return LayoutThemeChromiumDefault::extraDefaultStyleSheet() +
+ return LayoutThemeDefault::extraDefaultStyleSheet() +
String(themeChromiumTizenCss, sizeof(themeChromiumTizenCss));
}
#ifndef RenderThemeChromiumTizen_h
#define RenderThemeChromiumTizen_h
-#include "core/layout/LayoutThemeChromiumDefault.h"
+#include "core/layout/LayoutThemeDefault.h"
namespace blink {
-class RenderThemeChromiumTizen final : public LayoutThemeChromiumDefault {
+class RenderThemeChromiumTizen final : public LayoutThemeDefault {
public:
static PassRefPtr<LayoutTheme> create();
String extraDefaultStyleSheet() override;
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/scoped_vector.h"
-#include "cc/base/ref_counted_managed.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gl/gl_bindings.h"
#include "gpu/command_buffer/service/mailbox_manager_impl.h"
#include "ui/gl/gl_context.h"
#include "ui/gl/gl_share_group.h"
+#include "ui/gl/gpu_timing.h"
#if defined(TIZEN_DISABLE_GPU_THREAD)
#include "base/command_line.h"
#endif
return handle_;
}
- void OnSetSwapInterval(int interval) override {
+ virtual scoped_refptr<gfx::GPUTimingClient> CreateGPUTimingClient() override {
+ return 0;
+ }
+
+ virtual void OnSetSwapInterval(int interval) override {
NOTREACHED();
}
],
}],
- ['_target_name=="gesture_detection"', {
- 'sources/': [
- ['exclude', 'gesture_detection/gesture_configuration_default\\.cc$']
- ],
- 'sources': [
- 'events/gesture_detection/gesture_configuration_efl.cc',
- ],
- }],
+# [M44_2403] Temporary disabling the gesture_detection setting for switching to new chromium
+# FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14041
+# ['_target_name=="gesture_detection"', {
+# 'sources/': [
+# ['exclude', 'gesture_detection/gesture_configuration_default\\.cc$']
+# ],
+# 'sources': [
+# 'events/gesture_detection/gesture_configuration_efl.cc',
+# ],
+# }],
], # target_conditions
} # target_defaults
NOTIMPLEMENTED();
}
-void AutofillManagerDelegateEfl::OnUnmaskVerificationResult(bool success) {
+void AutofillManagerDelegateEfl::OnUnmaskVerificationResult(GetRealPanResult result) {
NOTIMPLEMENTED();
}
return nullptr;
}
+rappor::RapporService* AutofillManagerDelegateEfl::GetRapporService() {
+ NOTIMPLEMENTED();
+}
+
void AutofillManagerDelegateEfl::HideAutofillPopup() {
DCHECK(web_contents_);
if (popup_controller_) {
return false;
}
+void AutofillManagerDelegateEfl::PropagateAutofillPredictions(
+ content::RenderFrameHost* rfh,
+ const std::vector<autofill::FormStructure*>& forms) {
+ NOTIMPLEMENTED();
+}
+
bool AutofillManagerDelegateEfl::IsAutocompleteSavingEnabled() {
if (webview_)
return webview_->GetSettings()->formCandidateData();
HideAutofillPopup();
}
-void AutofillManagerDelegateEfl::DetectAccountCreationForms(
- content::RenderFrameHost* rfh,
- const std::vector<autofill::FormStructure*>& forms) {
- DCHECK(web_contents_);
- PasswordGenerationManager* manager =
- PasswordManagerClientEfl::GetGenerationManagerFromWebContents(
- web_contents_);
- if (manager)
- manager->DetectAccountCreationForms(forms);
-}
-
AutofillPopupViewEfl * AutofillManagerDelegateEfl::GetOrCreatePopupController() {
if (webview_ && !popup_controller_)
popup_controller_ = new AutofillPopupViewEfl(webview_);
void UpdateAutofillPopupDataListValues(
const std::vector<base::string16>& values,
const std::vector<base::string16>& labels) override;
- void OnUnmaskVerificationResult(bool success) override;
+ void OnUnmaskVerificationResult(GetRealPanResult result) override;
bool HasCreditCardScanFeature() override;
void ScanCreditCard(const CreditCardScanCallback& callback) override;
void OnFirstUserGestureObserved() override;
void LinkClicked(const GURL& url, WindowOpenDisposition disposition) override;
IdentityProvider* GetIdentityProvider() override;
+ rappor::RapporService* GetRapporService() override;
void HideAutofillPopup() override;
bool IsAutocompleteEnabled() override;
- bool IsAutocompleteSavingEnabled();
- void DetectAccountCreationForms(
+ void PropagateAutofillPredictions(
content::RenderFrameHost* rfh,
const std::vector<autofill::FormStructure*>& forms) override;
+ bool IsAutocompleteSavingEnabled();
// content::WebContentsObserver implementation.
void DidNavigateMainFrame(const content::LoadCommittedDetails& details,
const content::FrameNavigateParams& params) override;
return true;
}
-void AutofillPrefStore::SetValue(const std::string& key, base::Value* value) {
+void AutofillPrefStore::SetValue(const std::string& key,
+ base::Value* value,
+ uint32 flags) {
DCHECK(value);
if (prefs_.SetValue(key, value))
- ReportValueChanged(key);
+ ReportValueChanged(key, flags);
}
-void AutofillPrefStore::SetValueSilently(const std::string& key, base::Value* value) {
+void AutofillPrefStore::SetValueSilently(const std::string& key,
+ base::Value* value,
+ uint32 flags) {
prefs_.SetValue(key, value);
}
-void AutofillPrefStore::RemoveValue(const std::string& key) {
+void AutofillPrefStore::RemoveValue(const std::string& key, uint32 flags) {
if (prefs_.RemoveValue(key))
- ReportValueChanged(key);
+ ReportValueChanged(key, flags);
}
bool AutofillPrefStore::ReadOnly() const {
void AutofillPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate_raw) {
}
-void AutofillPrefStore::ReportValueChanged(const std::string& key) {
+void AutofillPrefStore::ReportValueChanged(const std::string& key, uint32 flags) {
FOR_EACH_OBSERVER(Observer, observers_, OnPrefValueChanged(key));
}
// PersistentPrefStore overrides:
bool GetMutableValue(const std::string& key,
base::Value** result) override;
- void ReportValueChanged(const std::string& key) override;
- void SetValue(const std::string& key, base::Value* value) override;
+ void ReportValueChanged(const std::string& key, uint32 flags) override;
+ void SetValue(const std::string& key,
+ base::Value* value,
+ uint32 flags) override;
void SetValueSilently(const std::string& key,
- base::Value* value) override;
- void RemoveValue(const std::string& key) override;
+ base::Value* value,
+ uint32 flags) override;
+ void RemoveValue(const std::string& key, uint32 flags) override;
bool ReadOnly() const override;
PrefReadError GetReadError() const override;
PersistentPrefStore::PrefReadError ReadPrefs() override;
CHECK(srv);
content::ContentBrowserClient* client = content::GetContentClientExport()->browser();
mgr = new PersonalDataManager(client->GetApplicationLocale());
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14042
mgr->Init(WebDataServiceFactory::GetAutofillWebDataForProfile(), srv, ctx->IsOffTheRecord());
+#endif
mgr->AddObserver(this);
personal_data_manager_id_map_.AddWithID(mgr, uniqueId);
}
int FaviconDownloader::DownloadFavicon(const GURL &faviconUrl) {
return web_contents()->DownloadImage(faviconUrl,
- true,
- 0,
+ true, /* bool is_favicon */
+ 0, /* uint32_t max_bitmap_size */
+ false, /* bool bypass_cache */
base::Bind(&FaviconDownloader::DidDownloadFavicon,
m_weakPtrFactory.GetWeakPtr()));
}
NOTIMPLEMENTED();
}
- virtual void WebContentsDestroyed(content::WebContents* web_contents) override
+ virtual void ResetDialogState(content::WebContents* web_contents) override
{
NOTIMPLEMENTED();
}
if (!saved_data)
return false;
- saved_data->notification_delegate->NotificationClosed(by_user);
+ saved_data->notification_delegate->NotificationClosed();
notifications_map_.Remove(notification_id);
return true;
}
|| (notification_show_callback_ && notification_cancel_callback_);
if (!has_callbacks) {
- delegate->NotificationClosed(false);
+ delegate->NotificationClosed();
return;
}
: SSLHostStateDelegate::DENIED;
}
+void SSLHostStateDelegateEfl::RevokeUserAllowExceptions(
+ const std::string& host) {
+ cert_policy_for_host_.erase(host);
+}
+
+bool SSLHostStateDelegateEfl::HasAllowException(const std::string& host) const {
+ NOTIMPLEMENTED();
+}
+
}
bool DidHostRunInsecureContent(const std::string& host,
int pid) const override;
+ // Revokes all SSL certificate error allow exceptions made by the user for
+ // |host|.
+ void RevokeUserAllowExceptions(const std::string& host) override;
+
+ // Returns whether the user has allowed a certificate error exception for
+ // |host|. This does not mean that *all* certificate errors are allowed, just
+ // that there exists an exception. To see if a particular certificate and
+ // error combination exception is allowed, use QueryPolicy().
+ bool HasAllowException(const std::string& host) const override;
+
private:
// Certificate policies for each host.
std::map<std::string, internal::CertPolicy> cert_policy_for_host_;
virtual base::FilePath GetPath() const override;
+ virtual PermissionManager* GetPermissionManager() override
+ { return 0; }
+
net::URLRequestContextGetter* CreateRequestContext(
content::ProtocolHandlerMap* protocol_handlers,
URLRequestInterceptorScopedVector request_interceptors);
#include "base/command_line.h"
#include "content/public/common/content_switches.h"
+using devtools_http_handler::DevToolsDelegateEfl;
namespace content {
#include "base/memory/scoped_ptr.h"
#include "content/public/browser/browser_main_parts.h"
-namespace content {
-
+namespace devtools_http_handler {
class DevToolsDelegateEfl;
+}
+
+namespace content {
// EFL port implementation of BrowserMainParts.
// This class contains different "stages" to be executed by BrowserMain(),
virtual void PostMainMessageLoopRun() override;
private:
- DevToolsDelegateEfl* devtools_delegate_;
+ devtools_http_handler::DevToolsDelegateEfl* devtools_delegate_;
DISALLOW_COPY_AND_ASSIGN(BrowserMainPartsEfl);
};
p_command_line->AppendSwitch(switches::kEnableSpatialNavigation);
p_command_line->AppendSwitch(switches::kMainFrameResizesAreOrientationChanges);
p_command_line->AppendSwitch(switches::kForceAccelerated2dCanvas);
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14040
p_command_line->AppendSwitch(cc::switches::kEnableParallelCanvasMode);
+#endif // EWK_BRINGUP
#else
p_command_line->AppendSwitch(switches::kIgnoreGpuBlacklist);
#endif
void CommandLineEfl::AppendMemoryOptimizationSwitches(
base::CommandLine* command_line) {
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14040
// For optimizing tile buffer size.
command_line->AppendSwitchASCII(switches::kDefaultTileRoundUp, "16");
command_line->AppendSwitch(switches::kEnableMultipleTextureSizes);
// For adding runtime switch to configure the discardable image cache size.
command_line->AppendSwitchASCII(switches::kImageCacheSize, "0");
+#endif
// For testing link disambiguation popup
command_line->AppendSwitch(switches::kEnableLinkDisambiguationPopup);
#include "common/content_switches_efl.h"
#include "content/browser/web_contents/web_contents_view_efl.h"
#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/permission_type.h"
#include "content/public/browser/render_widget_host.h"
#include "content/public/browser/render_widget_host_iterator.h"
#include "content/public/browser/resource_dispatcher_host.h"
}
}
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14043
void ContentBrowserClientEfl::RequestPermission(
content::PermissionType permission,
content::WebContents* web_contents,
browser_context->GetGeolocationPermissionContext();
switch (permission) {
- case content::PERMISSION_GEOLOCATION: {
+ case content::PermissionType::GEOLOCATION: {
if (!browser_context) {
LOG(ERROR) << "Dropping GeolocationPermission request";
result_callback.Run(false);
result_callback);
break;
}
- case content::PERMISSION_NOTIFICATIONS:
+ case content::PermissionType::NOTIFICATIONS:
{
#if defined(ENABLE_NOTIFICATIONS)
notification_controller_->RequestPermission(web_contents,
#endif
break;
}
- case content::PERMISSION_PROTECTED_MEDIA_IDENTIFIER:
- case content::PERMISSION_MIDI_SYSEX:
- case content::PERMISSION_PUSH_MESSAGING: {
+ case content::PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+ case content::PermissionType::MIDI_SYSEX:
+ case content::PermissionType::PUSH_MESSAGING: {
NOTIMPLEMENTED() << "RequestPermission not implemented for "
- << permission;
+ << static_cast<int>(permission);
ContentBrowserClient::RequestPermission(permission,
web_contents,
bridge_id,
break;
}
default: {
- NOTREACHED() << "Invalid RequestPermission for " << permission;
+ NOTREACHED() << "Invalid RequestPermission for "
+ << static_cast<int>(permission);
}
}
}
+#endif
void ContentBrowserClientEfl::SetCertificatePem(const net::SSLInfo& ssl_info,
int render_process_id,
int render_process_id,
int render_view_id);
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14043
void RequestPermission(
content::PermissionType permission,
content::WebContents* web_contents,
const GURL& requesting_frame,
bool user_gesture,
const base::Callback<void(bool)>& result_callback) override;
+#endif
content::DevToolsManagerDelegate* GetDevToolsManagerDelegate() override;
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
#include "net/cookies/canonical_cookie.h"
+#include "net/cookies/cookie_monster.h"
#include "net/cookies/cookie_options.h"
#include "net/cookies/cookie_util.h"
#include "public/ewk_cookie_manager.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
+#include "components/devtools_discovery/devtools_target_descriptor.h"
+#include "components/devtools_http_handler/devtools_http_handler.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/devtools_agent_host.h"
-#include "content/public/browser/devtools_http_handler.h"
-#include "content/public/browser/devtools_target.h"
+#include "content/public/browser/devtools_frontend_host.h"
+#include "content/public/common/content_client.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/url_constants.h"
#include "content/public/common/user_agent.h"
#include <unistd.h>
using content::BrowserThread;
+using devtools_http_handler::DevToolsHttpHandler;
namespace {
const int kBackLog = 10;
class TCPServerSocketFactory
- : public content::DevToolsHttpHandler::ServerSocketFactory {
+ : public DevToolsHttpHandler::ServerSocketFactory {
public:
TCPServerSocketFactory(const std::string& address, uint16 port)
: address_(address),
} // namespace
-namespace content {
+namespace devtools_http_handler {
DevToolsDelegateEfl::DevToolsDelegateEfl(int port)
: port_(0)
sock->GetLocalAddress(&givenIp);
port_ = givenIp.port();
- scoped_ptr<content::DevToolsHttpHandler::ServerSocketFactory> factory(
+ scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> factory(
new TCPServerSocketFactory(addr, port_));
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14044
devtools_http_handler_.reset(
content::DevToolsHttpHandler::Start(factory.Pass(),
std::string(), this, base::FilePath()));
+#endif
}
DevToolsDelegateEfl::~DevToolsDelegateEfl() {
IDR_CONTENT_SHELL_DEVTOOLS_DISCOVERY_PAGE).as_string();
}
-bool DevToolsDelegateEfl::BundlesFrontendResources() {
- return true;
+std::string DevToolsDelegateEfl::GetFrontendResource(const std::string& path) {
+ return content::DevToolsFrontendHost::GetFrontendResource(path).as_string();
}
-base::FilePath DevToolsDelegateEfl::GetDebugFrontendDir() {
- return base::FilePath();
+std::string DevToolsDelegateEfl::GetPageThumbnailData(const GURL& url) {
+ return std::string();
}
} // namespace content
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
-#include "content/public/browser/devtools_http_handler_delegate.h"
+#include "components/devtools_http_handler/devtools_http_handler_delegate.h"
namespace content {
-
class BrowserContext;
+}
+
+namespace devtools_http_handler {
+
class DevToolsHttpHandler;
// This class is to create RemoteInspector Server(Remote Debugger) and return devtools front resources.
// ChromiumDevToolsHttpHandler::Delegate overrides.
virtual std::string GetDiscoveryPageHTML() override;
- virtual bool BundlesFrontendResources() override;
- virtual base::FilePath GetDebugFrontendDir() override;
+ virtual std::string GetFrontendResource(const std::string& path) override;
+ virtual std::string GetPageThumbnailData(const GURL& url) override;
DevToolsHttpHandler* devtools_http_handler() {
return devtools_http_handler_.get();
}
private:
int port_;
- BrowserContext* browser_context_;
+ content::BrowserContext* browser_context_;
scoped_ptr<DevToolsHttpHandler> devtools_http_handler_;
};
const char kTargetTypeServiceWorker[] = "service_worker";
const char kTargetTypeOther[] = "other";
-class Target : public content::DevToolsTarget {
+class Target : public devtools_discovery::DevToolsTargetDescriptor {
public:
explicit Target(scoped_refptr<DevToolsAgentHost> agent_host);
virtual std::string GetDescription() const override { return std::string(); }
virtual GURL GetURL() const override { return agent_host_->GetURL(); }
virtual GURL GetFaviconURL() const override { return favicon_url_; }
- virtual base::TimeTicks GetLastActivityTime() const override {
+ virtual base::Time GetLastActiveTime() const override {
return last_activity_time_;
}
virtual bool IsAttached() const override {
std::string title_;
GURL url_;
GURL favicon_url_;
- base::TimeTicks last_activity_time_;
+ base::Time last_activity_time_;
};
Target::Target(scoped_refptr<content::DevToolsAgentHost> agent_host)
WebContents* web_contents = agent_host_->GetWebContents();
if (!web_contents)
return false;
- web_contents->GetRenderViewHost()->ClosePage();
+ web_contents->ClosePage();
return true;
}
return NULL;
}
-std::string DevToolsManagerDelegateEfl::GetPageThumbnailData(const GURL& url) {
- return std::string();
-}
-
-scoped_ptr<DevToolsTarget> DevToolsManagerDelegateEfl::CreateNewTarget(const GURL& url) {
- return scoped_ptr<DevToolsTarget>();
-}
-
-void DevToolsManagerDelegateEfl::EnumerateTargets(TargetCallback callback) {
- TargetList targets;
- DevToolsAgentHost::List agents = DevToolsAgentHost::GetOrCreateAll();
- for (DevToolsAgentHost::List::iterator it = agents.begin();
- it != agents.end();
- ++it) {
- targets.push_back(new Target(*it));
- }
- callback.Run(targets);
-}
-
} // namespace content
#include "base/basictypes.h"
+#include "components/devtools_discovery/devtools_target_descriptor.h"
#include "content/public/browser/devtools_manager_delegate.h"
-#include "content/public/browser/devtools_target.h"
namespace content {
virtual base::DictionaryValue* HandleCommand(
content::DevToolsAgentHost* agent_host,
base::DictionaryValue* command_dict) override;
- virtual scoped_ptr<content::DevToolsTarget> CreateNewTarget(
- const GURL& url) override;
- virtual void EnumerateTargets(TargetCallback callback) override;
- virtual std::string GetPageThumbnailData(const GURL& url) override;
private:
DISALLOW_COPY_AND_ASSIGN(DevToolsManagerDelegateEfl);
'<(DEPTH)/components/components.gyp:sessions_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:password_manager_core_common',
'<(DEPTH)/components/components.gyp:password_manager_core_browser',
'<(DEPTH)/components/components.gyp:plugins_renderer',
unsigned int EWebContext::InspectorServerStart(unsigned int port) {
InspectorServerStop();
- inspector_server_ = new content::DevToolsDelegateEfl(port);
+ inspector_server_ = new devtools_http_handler::DevToolsDelegateEfl(port);
return inspector_server_ ? inspector_server_->port() : 0;
}
scoped_ptr<EwkDidStartDownloadCallback> start_download_callback_;
scoped_ptr<EwkMimeOverrideCallback> mime_override_callback_;
int m_pixmap;
- content::DevToolsDelegateEfl* inspector_server_;
+ devtools_http_handler::DevToolsDelegateEfl* inspector_server_;
scoped_ptr<EWebContextNotificationCallback> notification_cb_;
};
JavaScriptCallbackDetails* script_callback_data = new JavaScriptCallbackDetails(callback, userdata, evas_object_);
render_frame_host->ExecuteJavaScript(js_script, base::Bind(&JavaScriptComplete, base::Owned(script_callback_data)));
} else {
- // We use ExecuteJavaScriptForTests instead of ExecuteJavaScript because
- // ExecuteJavaScriptForTests sets user_gesture to true. This was the
+ // We use ExecuteJavaScriptWithUserGestureForTests instead of ExecuteJavaScript because
+ // ExecuteJavaScriptWithUserGestureForTests sets user_gesture to true. This was the
// behaviour is m34, and we want to keep it that way.
- render_frame_host->ExecuteJavaScriptForTests(js_script);
+ render_frame_host->ExecuteJavaScriptWithUserGestureForTests(js_script);
}
return true;
if (inspector_server_) {
inspector_server_->Stop(); // Asynchronous releas inside Stop()
}
- inspector_server_ = new content::DevToolsDelegateEfl(port);
+ inspector_server_ = new devtools_http_handler::DevToolsDelegateEfl(port);
return inspector_server_ ? inspector_server_->port() : 0;
}
#include "ui/gfx/geometry/size.h"
#include "web_contents_delegate_efl.h"
+namespace devtools_http_handler {
+class DevToolsDelegateEfl;
+}
+
namespace content {
class RenderViewHost;
class RenderWidgetHostViewEfl;
class WebContentsDelegateEfl;
class ContextMenuControllerEfl;
-class DevToolsDelegateEfl;
class WebContentsViewEfl;
class PopupControllerEfl;
}
IDMap<WebApplicationCapableGetCallback, IDMapOwnPointer> web_app_capable_get_callback_map_;
scoped_ptr<NotificationPermissionCallback> notification_permission_callback_;
scoped_ptr<PermissionPopupManager> permission_popup_manager_;
- content::DevToolsDelegateEfl* inspector_server_;
+ devtools_http_handler::DevToolsDelegateEfl* inspector_server_;
scoped_ptr<ScrollDetector> scroll_detector_;
#if defined(OS_TIZEN_MOBILE)
content::FileChooserParams::Mode filechooser_mode_;
content::RenderProcessHostImpl::RegisterRendererMainThreadFactory(
content::CreateInProcessRendererThread);
GpuProcessHost::RegisterGpuMainThreadFactory(
- content::CreateInProcessGpuThread);
+ reinterpret_cast<content::GpuMainThreadFactoryFunction>(content::CreateInProcessGpuThread));
}
#ifndef NDEBUG
Name: chromium-ewk
Description: EWK API based on chromium-efl engine
-Version: 42.2311.0.11-1
+Version: 44.2403.0.31-1
Requires: chromium-efl
Libs: -L${libdir} -lchromium-ewk
Cflags: -I${includedir}/chromium-ewk
showPopup();
#else
GError* error = NULL;
+#if !defined(EWK_BRINGUP)
+// [M44_2403] Temporary disabling the codes for switching to new chromium
+// FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14045
gboolean ret = g_app_info_launch_default_for_uri(
full_content_.c_str(), NULL, &error);
if (!ret) {
LOG(WARNING) << "Failed to launch default application for: "
<< full_content_ << ", " << error->message;
}
+#endif // EWK_BRINGUP
#endif
}
return true;
}
-void ContentRendererClientEfl::DidCreateScriptContext(blink::WebFrame* frame,
- v8::Handle<v8::Context> context,
- int extension_group,
- int world_id) {
- const content::RenderView* render_view = content::RenderView::FromWebView(frame->view());
- if (wrt_widget_)
- wrt_widget_->StartSession(context, render_view->GetRoutingID(),
- frame->document().baseURL().string().utf8());
-}
-
void ContentRendererClientEfl::WillReleaseScriptContext(blink::WebFrame* frame,
v8::Handle<v8::Context> context,
int world_id) {
#include "common/web_view_settings.h"
#include "content/public/renderer/content_renderer_client.h"
+#include "content/public/renderer/render_frame_observer.h"
#include "renderer/content_renderer_client_efl.h"
#include "v8/include/v8.h"
#include "renderer/render_process_observer_efl.h"
const blink::WebPluginParams& params,
blink::WebPlugin** plugin) override;
- void DidCreateScriptContext(blink::WebFrame* frame,
- v8::Handle<v8::Context> context,
- int extension_group,
- int world_id) override;
-
void WillReleaseScriptContext(blink::WebFrame* frame,
v8::Handle<v8::Context>,
int world_id);
global->Set(gin::StringToV8(isolate, "plugin"),
gin::CreateHandle(isolate, this).ToV8());
}
+
+blink::WebPlugin* PluginPlaceholderEfl::CreatePlugin() {
+}
// WebViewPlugin::Delegate (via PluginPlaceholder) method
void BindWebFrame(blink::WebFrame* frame) override;
+ blink::WebPlugin* CreatePlugin() override;
DISALLOW_COPY_AND_ASSIGN(PluginPlaceholderEfl);
};
#include "content/public/browser/cookie_store_factory.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/url_constants.h"
-#include "content/browser/net/sqlite_persistent_cookie_store.h"
#include "net/base/cache_type.h"
#include "net/cert/cert_verifier.h"
#include "net/dns/host_resolver.h"
#include "net/dns/mapped_host_resolver.h"
+#include "net/extras/sqlite/sqlite_persistent_cookie_store.h"
#include "net/http/http_auth_handler_factory.h"
#include "net/http/http_cache.h"
#include "net/http/http_server_properties_impl.h"
#include "network_delegate_efl.h"
#include "http_user_agent_settings_efl.h"
+using net::SQLitePersistentCookieStore;
+
namespace content {
namespace {
cookie_path,
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB),
- persist_session_cookies, NULL, NULL);
+ persist_session_cookies, NULL);
} else {
NOTREACHED() << "The cookie storage directory could not be created";
return;
}
void WebContentsDelegateEfl::EnterFullscreenModeForTab(content::WebContents* web_contents,
- const GURL& origin) {
+ const GURL& origin, int display_id) {
is_fullscreen_ = true;
web_view_->SmartCallback<EWebViewCallbacks::EnterFullscreen>().call();
}
return false;
}
-void WebContentsDelegateEfl::OrientationLock(
- blink::WebScreenOrientationLockType orientation) {
- WebViewDelegateEwk::GetInstance().RequestHandleOrientationLock(web_view_,
- static_cast<int>(orientation));
-}
-
-void WebContentsDelegateEfl::OrientationUnlock() {
- WebViewDelegateEwk::GetInstance().RequestHandleOrientationUnlock(web_view_);
-}
-
} //namespace content
virtual void CloseContents(WebContents* source) override;
void EnterFullscreenModeForTab(content::WebContents* web_contents,
- const GURL& origin) override;
+ const GURL& origin,
+ int display_id = 0) override;
void ExitFullscreenModeForTab(content::WebContents* web_contents) override;
virtual bool IsFullscreenForTabOrPending(
bool PreHandleGestureEvent(WebContents* source,
const blink::WebGestureEvent& event) override;
- void OrientationLock(blink::WebScreenOrientationLockType orientation);
- void OrientationUnlock();
-
private:
void OnGetContentSecurityPolicy(IPC::Message* reply_msg);
void OnWrtPluginMessage(const Ewk_Wrt_Message_Data& data);
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="42.2311.0.11">
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="44.2403.0.31">
<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>
],
'cflags': [
'<!@(pkg-config --cflags dlog)',
+ '<!@(pkg-config --cflags dbus-glib-1)',
],
'link_settings': {
'ldflags': [
'<!@(pkg-config --libs-only-L --libs-only-other dlog)',
+ '<!@(pkg-config --libs-only-L --libs-only-other dbus-glib-1)',
],
'libraries': [
'<!@(pkg-config --libs-only-l dlog)',
+ '<!@(pkg-config --libs-only-l dbus-glib-1)',
]
},
}]
Name: chromium-efl
Summary: Chromium EFL
# Set by by scripts/update-chromium-version.sh
-%define ChromiumVersion 42.2311.0
-%define Week 11
+%define ChromiumVersion 44.2403.0
+%define Week 31
Version: %{ChromiumVersion}.%{Week}
Release: 1
# The 'Group' should be specified as one of the following valid group list.
Requires(postun): /sbin/ldconfig
BuildRequires: bison, edje-tools, expat-devel, flex, gettext, gperf, libcap-devel
-BuildRequires: libjpeg-turbo-devel, perl, python, python-xml, vi, which
+BuildRequires: libjpeg-turbo-devel, perl, python, python-xml, which
BuildRequires: pkgconfig(capi-appfw-application)
BuildRequires: pkgconfig(capi-location-manager)
BuildRequires: pkgconfig(capi-media-audio-io)
BuildRequires: pkgconfig(capi-system-info)
BuildRequires: pkgconfig(capi-system-system-settings)
BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(dbus-glib-1)
BuildRequires: pkgconfig(ecore)
BuildRequires: pkgconfig(ecore-evas)
BuildRequires: pkgconfig(ecore-imf)
%else # for TV
BuildRequires: pkgconfig(audio-session-mgr)
BuildRequires: pkgconfig(mm-session)
+%endif
+
%if "%{?chromium_efl_tizen_version}%{!?chromium_efl_tizen_version:0}" == "2.4"
BuildRequires: pkgconfig(glesv2)
%endif
-%endif
# Version Conditions for Every Targets
%if "%{?chromium_efl_tizen_version}%{!?chromium_efl_tizen_version:0}" >= "2.4"
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Manifest xmlns="http://schemas.tizen.org/2012/12/manifest">
<Id>kmcele1k1p</Id>
- <Version>42.2311.0.11</Version>
+ <Version>44.2403.0.31</Version>
<Type>C++App</Type>
<Descriptions>
<Description Locale="eng-PH"/>
'tizen_multimedia_support%': 1,
'tizen_multimedia_eme_support%': 1,
- 'tizen_disable_gpu_thread%': 1,
+# [M44_2403] Temporary disabling the tizen_disable_gpu_thread for switching to new chromium
+# FIXME: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=14046
+ 'tizen_disable_gpu_thread%': 0,
'data_dir%' : '/usr/share/chromium-efl/',
'exe_dir%' : '/usr/lib/chromium-efl/',
projects / platform / framework / web / chromium-efl.git / commitdiff