# SVN revision while Blink is still in SVN.
blink_upstream_rev = '191638' #TODO(TK) : need to update revision number
-efl_integration_branch = 'origin/dev/m48_2564'
+efl_integration_branch = 'origin/dev/m49_2623'
ct_git = 'ssh://165.213.202.130:29418/webplatform'
crosswalk_git = 'https://github.com/crosswalk-project'
"""Calculate additional variables for use in the build (called by gyp)."""
default_variables.setdefault('OS', 'linux')
+ default_variables.setdefault('gcc_version', '49')
default_variables.setdefault('SHARED_LIB_SUFFIX', '.so')
default_variables.setdefault('SHARED_LIB_DIR',
os.path.join('$!PRODUCT_DIR', 'lib'))
-Dbuilding_for_tizen_tv=0
-Dclang=${USE_CLANG}
-Dwerror=
+ -Duse_sysroot=0
-Duse_wayland=0
"
}
fi
if [ "$tizen_version" == "3.0" ]; then
- ADDITIONAL_GYP_PARAMETERS+="-Dtizen_multimedia_support=1
+ # [M49_2623] Temporary disabling the flag.
+ # FIXME: http://165.213.149.170/jira/browse/TWF-610
+ ADDITIONAL_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
+ -Dtizen_tbm_support=0
"
else
ADDITIONAL_GYP_PARAMETERS+="-Dtizen_multimedia_support=0
#define BASE_MESSAGE_LOOP_MESSAGE_PUMP_EFL_H_
#include "base/base_export.h"
-#include "base/basictypes.h"
#include "base/message_loop/message_pump.h"
#include "base/threading/non_thread_safe.h"
#ifndef Tizen_Version_h
#define Tizen_Version_h
-#include "third_party/WebKit/Source/config.h"
-
-#if OS(TIZEN)
+#if defined(OS_TIZEN)
#define TIZEN_VERSION (TIZEN_MAJOR_VERSION * 10000 + TIZEN_MINOR_VERSION * 100 + TIZEN_PATCH_VERSION)
#define TIZEN_VERSION_EQ(major, minor, patch) \
#define TIZEN_VERSION_EQ(major, minor, patch) 0
#define TIZEN_VERSION_AT_LEAST(major, minor, patch) 0
-#endif // OS(TIZEN)
+#endif // defined(OS_TIZEN)
#endif // Tizen_Version_h
void BrowserMediaPlayerManagerEfl::OnNewFrameAvailable(
int player_id,
base::SharedMemoryHandle foreign_memory_handle,
- uint32 length, base::TimeDelta timestamp) {
+ uint32_t length, base::TimeDelta timestamp) {
Send(new MediaPlayerEflMsg_NewFrameAvailable(
GetRoutingID(), player_id, foreign_memory_handle, length, timestamp));
}
void OnNewFrameAvailable(
int player_id,
base::SharedMemoryHandle foreign_memory_handle,
- uint32 length, base::TimeDelta timestamp) override;
+ uint32_t length, base::TimeDelta timestamp) override;
#if defined(TIZEN_TBM_SUPPORT)
void OnNewTbmBufferAvailable(
#include "cc/output/compositor_frame.h"
#include "cc/output/output_surface.h"
#include "cc/output/output_surface_client.h"
+#include "cc/raster/single_thread_task_graph_runner.h"
#include "cc/resources/resource_format.h"
#include "cc/resources/resource_provider.h"
#include "cc/surfaces/surface_id_allocator.h"
// The browser always keeps one texture as the frontbuffer.
// If it does not return a mailbox, it discarded the frontbuffer which is
// the oldest texture we sent.
- uint32 texture_id = pending_textures_.front().texture_id;
+ uint32_t texture_id = pending_textures_.front().texture_id;
if (texture_id)
context_provider_->ContextGL()->DeleteTextures(1, &texture_id);
pending_textures_.pop_front();
// static pages and IE Fish page.
// Black screen issue is seen on page in Tizen 2.4 product TV.
-#if TIZEN_VERSION_EQ(2,4,0) && OS(TIZEN_TV)
+#if TIZEN_VERSION_EQ(2,4,0) && defined(OS_TIZEN_TV)
context_provider_->ContextGL()->Finish();
#else
if (texture_upload_pending_) {
}
#endif
- uint32 sync_point =
+ uint32_t sync_point =
context_provider_->ContextGL()->InsertSyncPointCHROMIUM();
frame->gl_frame_data->sync_token = gpu::SyncToken(sync_point);
struct TransferableFrame {
TransferableFrame() : texture_id(0) {}
- TransferableFrame(uint32 texture_id,
+ TransferableFrame(uint32_t texture_id,
const gpu::Mailbox& mailbox,
const gfx::Size size)
: texture_id(texture_id), mailbox(mailbox), size(size) {}
- uint32 texture_id;
+ uint32_t texture_id;
gpu::Mailbox mailbox;
gfx::Size size;
gpu::SyncToken sync_token;
std::deque<TransferableFrame> pending_textures_;
std::queue<TransferableFrame> returned_textures_;
- uint32 fbo_;
+ uint32_t fbo_;
bool is_backbuffer_discarded_;
bool texture_upload_pending_;
cc::ResourceFormat format_;
void RemoveMirroringLayer(Layer* layer) override {}
};
-class SingleThreadTaskGraphRunner
- : public cc::TaskGraphRunner,
- public base::DelegateSimpleThread::Delegate {
+class SingleThreadTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
public:
- SingleThreadTaskGraphRunner()
- : worker_thread_(
- this,
- "CompositorTileWorker1",
- base::SimpleThread::Options(base::ThreadPriority::BACKGROUND)) {
- worker_thread_.Start();
- }
-
- ~SingleThreadTaskGraphRunner() override {
- Shutdown();
- worker_thread_.Join();
+ SingleThreadTaskGraphRunner() {
+ Start("CompositorTileWorker1", base::SimpleThread::Options());
}
- private:
- // Overridden from base::DelegateSimpleThread::Delegate:
- void Run() override { cc::TaskGraphRunner::Run(); }
-
- base::DelegateSimpleThread worker_thread_;
+ ~SingleThreadTaskGraphRunner() override { Shutdown(); }
};
-
base::LazyInstance<SingleThreadTaskGraphRunner> g_task_graph_runner = LAZY_INSTANCE_INITIALIZER;
}
return false;
}
-uint32 ContextFactoryEfl::GetImageTextureTarget(gfx::BufferFormat format,
+uint32_t ContextFactoryEfl::GetImageTextureTarget(gfx::BufferFormat format,
gfx::BufferUsage usage) {
return GL_TEXTURE_2D;
}
bool DoesCreateTestContexts() override;
- uint32 GetImageTextureTarget(gfx::BufferFormat format,
- gfx::BufferUsage usage) override;
+ uint32_t GetImageTextureTarget(gfx::BufferFormat format,
+ gfx::BufferUsage usage) override;
cc::SharedBitmapManager* GetSharedBitmapManager() override;
#include <Elementary.h>
#include "base/auto_reset.h"
-#include "base/basictypes.h"
#include "base/bind.h"
#include "base/command_line.h"
#include "base/callback_helpers.h"
IPC_BEGIN_MESSAGE_MAP(RenderWidgetHostViewEfl, message)
IPC_MESSAGE_HANDLER(ViewHostMsg_TextInputInFormStateChanged, OnTextInputInFormStateChanged)
IPC_MESSAGE_HANDLER(ViewHostMsg_SnapshotDataReceived, OnSnapshotDataReceived)
-#if defined(OS_TIZEN)
- IPC_MESSAGE_HANDLER(InputHostMsg_DidHandleKeyEvent, OnDidHandleKeyEvent);
-#endif
IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP()
return handled;
return this == consumer;
}
-void RenderWidgetHostViewEfl::DispatchCancelTouchEvent(ui::TouchEvent* event) {
-}
+void RenderWidgetHostViewEfl::DispatchCancelTouchEvent(
+ ui::GestureConsumer* raw_input_consumer,
+ ui::TouchEvent* event) {}
-void RenderWidgetHostViewEfl::DispatchGestureEvent(ui::GestureEvent* event) {
+void RenderWidgetHostViewEfl::DispatchGestureEvent(
+ GestureConsumer* raw_input_consumer,
+ ui::GestureEvent* event) {
HandleGesture(event);
}
if (!result->HasBitmap())
return;
- scoped_ptr<SkBitmap> snapshot = result->TakeBitmap().Pass();
+ scoped_ptr<SkBitmap> snapshot = std::move(result->TakeBitmap());
Evas_Object* image = NULL;
if (!snapshot.get()->empty()) {
scoped_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(request.Pass());
+ request->set_area(snapshot_area);
+ compositor_->root_layer()->RequestCopyOfOutput(std::move(request));
}
bool RenderWidgetHostViewEfl::RequestSnapshotAsync(const Eina_Rectangle rect,
void RenderWidgetHostViewEfl::BeginFrameSubscription(
scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) {
- delegated_frame_host_->BeginFrameSubscription(subscriber.Pass());
+ delegated_frame_host_->BeginFrameSubscription(std::move(subscriber));
}
void RenderWidgetHostViewEfl::EndFrameSubscription() {
GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
gpu::SyncToken sync_token;
if (gl_helper)
- sync_token = gpu::SyncToken(gl_helper->InsertSyncPoint());
+ gl_helper->GenerateSyncToken(&sync_token);
if (release_callback) {
// A release callback means the texture came from the compositor, so there
// should be no |subscriber_texture|.
SkAutoLockPixels scaled_bitmap_locker(scaled_bitmap);
media::CopyRGBToVideoFrame(
- reinterpret_cast<uint8*>(scaled_bitmap.getPixels()),
+ reinterpret_cast<uint8_t*>(scaled_bitmap.getPixels()),
scaled_bitmap.rowBytes(),
region_in_frame,
video_frame.get());
ui::LatencyInfo latency_info;
// The latency number should only be added if the timestamp is valid.
if (event.timeStampSeconds) {
- const int64 time_micros = static_cast<int64>(
+ const int64_t time_micros = static_cast<int64_t>(
event.timeStampSeconds * base::Time::kMicrosecondsPerSecond);
latency_info.AddLatencyNumberWithTimestamp(
ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
}
void RenderWidgetHostViewEfl::OnSwapCompositorFrame(
- uint32 output_surface_id, scoped_ptr<cc::CompositorFrame> frame) {
+ 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;
if (frame->gl_frame_data) {
cc::CompositorFrameAck ack;
- ack.gl_frame_data = frame->gl_frame_data.Pass();
+ 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_);
} else if (frame->delegated_frame_data) {
// ack is sent by delegated frame host
- delegated_frame_host_->SwapDelegatedFrame(
- output_surface_id, frame->delegated_frame_data.Pass(),
- frame->metadata.device_scale_factor, frame->metadata.latency_info,
- &frame->metadata.satisfies_sequences);
+ delegated_frame_host_->SwapDelegatedFrame(output_surface_id,
+ std::move(frame));
} else {
NOTREACHED();
}
#include <Evas_GL.h>
#include <Ecore_IMF_Evas.h>
-#include "base/basictypes.h"
#include "base/format_macros.h"
#include "base/id_map.h"
#include "content/browser/renderer_host/render_widget_host_view_base.h"
void UnlockCompositingSurface() override;
void OnSwapCompositorFrame(
- uint32 output_surface_id, scoped_ptr<cc::CompositorFrame> frame) override;
+ uint32_t output_surface_id, scoped_ptr<cc::CompositorFrame> frame) override;
void ClearCompositorFrame () override;
// ui::GestureEventHelper implementation.
bool CanDispatchToConsumer(ui::GestureConsumer* consumer) override;
- void DispatchCancelTouchEvent(ui::TouchEvent* event) override;
- void DispatchGestureEvent(ui::GestureEvent*) override;
+ void DispatchCancelTouchEvent(ui::GestureConsumer* raw_input_consumer,
+ ui::TouchEvent* event) override;
+ void DispatchGestureEvent(GestureConsumer* raw_input_consumer,
+ ui::GestureEvent*) override;
// IPC::Sender implementation:
bool Send(IPC::Message*) override;
magnifier_->Move(magnifier_point);
magnifier_->Show();
- if (handle == input_handle_)
+ if (handle == input_handle_.get())
return;
gfx::Vector2dF base_offset, extent_offset;
// When moving the handle we want to move only the extent point.
// Before doing so, we must make sure that the base point is set correctly.
- if (handle == start_handle_) {
+ if (handle == start_handle_.get()) {
dragging_handle_ = start_handle_.get();
stationary_handle_ = end_handle_.get();
#include <Elementary.h>
-#include "base/basictypes.h"
#include "base/files/file_path.h"
#include "base/strings/string16.h"
#include "third_party/skia/include/core/SkBitmap.h"
const scoped_refptr<base::SingleThreadTaskRunner>& client_task_runner,
base::SharedMemory* shm,
size_t size,
- int32 input_id)
+ int32_t input_id)
: client_(client),
client_task_runner_(client_task_runner),
shm_(shm),
scoped_ptr<base::SharedMemory> shm_;
size_t size_;
off_t bytes_used_;
- int32 input_id_;
+ int32_t input_id_;
GstBuffer* gst_buffer_;
};
TizenVideoDecodeAccelerator::~TizenVideoDecodeAccelerator() {
}
-bool TizenVideoDecodeAccelerator::Initialize(
- media::VideoCodecProfile profile,
- Client* client) {
+bool TizenVideoDecodeAccelerator::Initialize(const Config& config,
+ Client* client) {
GError* error = NULL;
GstElement* gst_decoder = NULL;
GstElement* gst_parser = NULL;
impl_->io_client_weak_factory_.reset(
new base::WeakPtrFactory<Client>(client));
- switch (profile) {
+ switch (config.profile) {
case media::H264PROFILE_BASELINE:
DVLOG(1) << "Initialize(): profile -> H264PROFILE_BASELINE";
break;
DVLOG(1) << "Initialize(): profile -> H264PROFILE_MAIN";
break;
default:
- LOG(ERROR) << "Initialize(): unsupported profile=" << profile;
+ LOG(ERROR) << "Initialize(): unsupported profile=" << config.profile;
return false;
};
}
void TizenVideoDecodeAccelerator::ReusePictureBuffer(
- int32 picture_buffer_id) {
+ int32_t picture_buffer_id) {
NOTIMPLEMENTED();
}
TizenVideoDecodeAccelerator();
~TizenVideoDecodeAccelerator() override;
- bool Initialize(media::VideoCodecProfile profile, Client* client) override;
+ bool Initialize(const Config& config, Client* client) override;
void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
void AssignPictureBuffers(
const std::vector<media::PictureBuffer>& buffers) override;
- void ReusePictureBuffer(int32 picture_buffer_id) override;
+ void ReusePictureBuffer(int32_t picture_buffer_id) override;
void Flush() override;
void Reset() override;
void Destroy() override;
base::Lock destroy_lock_;
base::ThreadChecker thread_checker_;
gfx::Size view_size_;
- uint32 gst_bitrate_;
+ uint32_t gst_bitrate_;
volatile bool is_running_;
volatile bool is_destroying_;
volatile bool can_feed_;
media::VideoEncodeAccelerator::kPlatformFailureError);
} else {
//copying data to shared memory.
- memcpy(static_cast<uint8*>(shm->memory()), map.data, map.size);
+ memcpy(static_cast<uint8_t*>(shm->memory()), map.data, map.size);
child_task_runner_->PostTask(
FROM_HERE,
base::Bind(&media::VideoEncodeAccelerator::Client::BitstreamBufferReady,
media::VideoPixelFormat input_format,
const gfx::Size& input_visible_size,
media::VideoCodecProfile output_profile,
- uint32 initial_bitrate,
+ uint32_t initial_bitrate,
Client* client) {
DVLOG(1) << " size :" << input_visible_size.ToString()
<< " max bitrate :" << MAX_BITRATE << "bps";
}
void TizenVideoEncodeAccelerator::RequestEncodingParametersChange(
- uint32 bitrate, uint32 framerate) {
+ uint32_t bitrate, uint32_t framerate) {
DVLOG(2) << " bitrate: " << bitrate
<< " framerate: " << framerate;
if (bitrate > 0 && bitrate != impl_->gst_bitrate_) {
g_object_set(G_OBJECT(impl_->encoder_),
kBitrateProperty,
#if defined(OS_TIZEN)
- std::min(bitrate, static_cast<uint32>(MAX_BITRATE)),
+ std::min(bitrate, static_cast<uint32_t>(MAX_BITRATE)),
#else
- std::min(bitrate, static_cast<uint32>(MAX_BITRATE)) / 1000,
+ std::min(bitrate, static_cast<uint32_t>(MAX_BITRATE)) / 1000,
#endif
NULL);
}
bufref->size_,
0,
bufref->size_,
- reinterpret_cast<uint8*>(bufref),
+ reinterpret_cast<uint8_t*>(bufref),
BitstreamBufferRef::Destruct);
if (!bufref->gst_buffer_ || !GST_IS_BUFFER(bufref->gst_buffer_)) {
LOG(INFO) << "gst_buffer_new_wrapped_full failed to allocate memory.";
bool Initialize(media::VideoPixelFormat input_format,
const gfx::Size& input_visible_size,
media::VideoCodecProfile output_profile,
- uint32 initial_bitrate,
+ uint32_t initial_bitrate,
Client* client) override;
void Encode(const scoped_refptr<media::VideoFrame>& frame,
bool force_keyframe) override;
void UseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer) override;
- void RequestEncodingParametersChange(uint32 bitrate,
- uint32 framerate) override;
+ void RequestEncodingParametersChange(uint32_t bitrate,
+ uint32_t framerate) override;
void Destroy() override;
private:
IPC_MESSAGE_ROUTED4(MediaPlayerEflMsg_NewFrameAvailable,
int /* player_id */,
base::SharedMemoryHandle /* Handle */,
- uint32 /* length */,
+ uint32_t /* length */,
base::TimeDelta /* time stamp */)
#if defined(TIZEN_TBM_SUPPORT)
#endif
base::FilePath GetDirDownloads() {
-#if !OS(TIZEN)
+#if !defined(OS_TIZEN)
return base::FilePath(FILE_PATH_LITERAL("/tmp/"));
#elif TIZEN_VERSION_AT_LEAST(3,0,0)
return base::FilePath(FILE_PATH_LITERAL(tzplatform_getenv(TZ_USER_DOWNLOADS)));
}
base::FilePath GetDirImages() {
-#if !OS(TIZEN)
+#if !defined(OS_TIZEN)
return base::FilePath(FILE_PATH_LITERAL("/tmp/"));
#elif TIZEN_VERSION_AT_LEAST(3,0,0)
return base::FilePath(FILE_PATH_LITERAL(tzplatform_getenv(TZ_USER_IMAGES)));
#ifndef CONTENT_COMMON_TTS_UTTERANCE_REQUEST_H_
#define CONTENT_COMMON_TTS_UTTERANCE_REQUEST_H_
-#include "base/basictypes.h"
#include "base/strings/string16.h"
#include <vector>
base::Unretained(this)));
}
-void MediaSourceDelegateEfl::AddBufferedTimeRange(base::TimeDelta start,
- base::TimeDelta end) {
- buffered_time_ranges_.Add(start, end);
+void MediaSourceDelegateEfl::OnBufferedTimeRangesChanged(
+ const media::Ranges<base::TimeDelta>& ranges) {
+ buffered_time_ranges_ = ranges;
}
blink::WebTimeRanges MediaSourceDelegateEfl::Buffered() const {
void MediaSourceDelegateEfl::OnEncryptedMediaInitData (
media::EmeInitDataType init_data_type,
- const std::vector<uint8>& init_data) {
+ const std::vector<uint8_t>& init_data) {
DCHECK(main_loop_->BelongsToCurrentThread());
if (emedia_init_data_cb_.is_null()) {
return;
void MediaSourceDelegateEfl::InitAudioDecryptingDemuxerStream() {
DCHECK(media_task_runner_->BelongsToCurrentThread());
- audio_decrypting_demuxer_stream_.reset(
- new media::DecryptingDemuxerStream(
- media_task_runner_, media_log_, set_cdm_ready_cb_,
- waiting_for_decryption_key_cb_));
+ audio_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
+ media_task_runner_, media_log_, waiting_for_decryption_key_cb_));
audio_decrypting_demuxer_stream_->Initialize(
- audio_stream_,
+ audio_stream_, set_cdm_ready_cb_,
base::Bind(
&MediaSourceDelegateEfl::OnAudioDecryptingDemuxerStreamInitDone,
media_weak_factory_.GetWeakPtr()));
void MediaSourceDelegateEfl::InitVideoDecryptingDemuxerStream() {
DCHECK(media_task_runner_->BelongsToCurrentThread());
- video_decrypting_demuxer_stream_.reset(
- new media::DecryptingDemuxerStream(
- media_task_runner_, media_log_, set_cdm_ready_cb_,
- waiting_for_decryption_key_cb_));
+ video_decrypting_demuxer_stream_.reset(new media::DecryptingDemuxerStream(
+ media_task_runner_, media_log_, waiting_for_decryption_key_cb_));
video_decrypting_demuxer_stream_->Initialize(
- video_stream_,
+ video_stream_, set_cdm_ready_cb_,
base::Bind(
&MediaSourceDelegateEfl::OnVideoDecryptingDemuxerStreamInitDone,
media_weak_factory_.GetWeakPtr()));
media::DemuxerStream::Type type,
media::DemuxerStream::Status status,
const scoped_refptr<media::DecoderBuffer>& buffer) {
- uint32 shared_memory_size = -1;
+ uint32_t shared_memory_size = -1;
base::SharedMemory shared_memory;
base::SharedMemoryHandle foreign_memory_handle;
~MediaSourceDelegateEfl();
//DemuxerHost implementation.
- void AddBufferedTimeRange(
- base::TimeDelta start,
- base::TimeDelta end) override;
+ void OnBufferedTimeRangesChanged(
+ const media::Ranges<base::TimeDelta>& ranges) override;
// Sets the duration of the media in microseconds.
// Duration may be kInfiniteDuration() if the duration is not known.
private:
void OnEncryptedMediaInitData(media::EmeInitDataType init_data_type,
- const std::vector<uint8>& init_data);
+ const std::vector<uint8_t>& init_data);
void OnDemuxerOpened();
void InitializeDemuxer();
void OnDemuxerInitDone(media::PipelineStatus status);
void RendererMediaPlayerManager::OnNewFrameAvailable(
int player_id,
base::SharedMemoryHandle foreign_memory_handle,
- uint32 length, base::TimeDelta timestamp) {
+ uint32_t length, base::TimeDelta timestamp) {
WebMediaPlayerEfl* player = GetMediaPlayer(player_id);
if (player)
player->OnNewFrameAvailable(foreign_memory_handle, length, timestamp);
private:
void OnNewFrameAvailable(int player_id,
base::SharedMemoryHandle foreign_memory_handle,
- uint32 length, base::TimeDelta timestamp);
+ uint32_t length, base::TimeDelta timestamp);
#if defined(TIZEN_TBM_SUPPORT)
void OnNewTbmBufferAvailable(int player_id, gfx::TbmBufferHandle tbm_handle,
void SetNetworkState(WebMediaPlayer::NetworkState state);
void OnNewFrameAvailable(base::SharedMemoryHandle foreign_memory_handle,
- uint32 length, base::TimeDelta timestamp);
+ uint32_t length, base::TimeDelta timestamp);
#if defined(TIZEN_TBM_SUPPORT)
void OnNewTbmBufferAvailable(
#include "content/renderer/media/efl/audio_decoder_efl.h"
-#include "base/basictypes.h"
#include "base/memory/shared_memory.h"
#include "base/posix/eintr_wrapper.h"
#include "base/process/process.h"
#include "base/strings/string_util.h"
#include "base/time/time.h"
+#include "content/child/thread_safe_sender.h"
#include "content/common/render_messages_efl.h"
#include "media/base/audio_bus.h"
#include "media/base/efl/webaudio_media_codec_info_efl.h"
#include "content/renderer/tts_dispatcher_efl.h"
#include "base/logging.h"
-#include "base/basictypes.h"
#include "base/strings/utf_string_conversions.h"
#include "content/common/tts_messages_efl.h"
#include "content/common/tts_utterance_request_efl.h"
TtsUtteranceRequest utterance;
utterance.id = id;
utterance.text = web_utterance.text().utf8();
- if (!web_utterance.lang().isEmpty() && web_utterance.lang().at(2) == '-')
+ if (!web_utterance.lang().isEmpty() &&
+ web_utterance.lang().utf8().at(2) == '-')
utterance.lang = web_utterance.lang().utf8().replace(2,1,"_");
utterance.voice = web_utterance.voice().utf8();
utterance.volume = web_utterance.volume();
#include <vector>
-#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/containers/hash_tables.h"
#include "content/common/content_export.h"
scoped_ptr<VibrationProviderClient> VibrationManagerImplEfl::provider_client_ = scoped_ptr<VibrationProviderClient>();
-void VibrationManagerImplEfl::Vibrate(int64 milliseconds) {
+void VibrationManagerImplEfl::Vibrate(int64_t milliseconds) {
if (provider_client_.get())
provider_client_->Vibrate(milliseconds);
}
// static
void VibrationManagerImpl::Create(
mojo::InterfaceRequest<VibrationManager> request) {
- new VibrationManagerImplEfl(request.Pass());
+ new VibrationManagerImplEfl(std::move(request));
}
} // namespace device
#include "device/vibration/vibration_manager_impl.h"
-#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "device/vibration/vibration_export.h"
#include "device/vibration/vibration_provider_client.h"
public:
explicit VibrationManagerImplEfl(
mojo::InterfaceRequest<VibrationManager> request)
- : binding_(this, request.Pass()) {}
+ : binding_(this, std::move(request)) {}
~VibrationManagerImplEfl() override {}
- void Vibrate(int64 milliseconds) override;
+ void Vibrate(int64_t milliseconds) override;
void Cancel() override;
static void RegisterProviderClient(VibrationProviderClient* provider_client);
return CollectBasicGraphicsInfo(gpu_info);
}
-CollectInfoResult CollectGpuID(uint32* vendor_id, uint32* device_id) {
+CollectInfoResult CollectGpuID(uint32_t* vendor_id, uint32_t* device_id) {
DCHECK(vendor_id && device_id);
*vendor_id = 0;
*device_id = 0;
#if defined(TIZEN_MULTIMEDIA_SUPPORT)
gpu_info->video_encode_accelerator_supported_profiles =
content::GpuVideoEncodeAccelerator::GetSupportedProfiles();
- gpu_info->video_decode_accelerator_supported_profiles =
- content::GpuVideoDecodeAccelerator::GetSupportedProfiles();
+ gpu_info->video_decode_accelerator_capabilities =
+ content::GpuVideoDecodeAccelerator::GetCapabilities();
#endif
return result;
}
}
void CapiAudioInputStream::OnAudioIOData(const AudioBus* audio_bus,
- uint32 hardware_delay_bytes,
+ uint32_t hardware_delay_bytes,
double normalized_volume) {
if (callback_)
callback_->OnData(this,audio_bus, hardware_delay_bytes, normalized_volume);
double normalized_volume = 0.0;
GetAgcVolume(&normalized_volume);
- uint32 hardware_delay_bytes =
+ uint32_t hardware_delay_bytes =
params_.GetBytesPerSecond() *
static_cast<int>(params_.GetBufferDuration().InSeconds() * 2) *
params_.channels();
double GetVolume() override;
bool IsMuted();
void OnAudioIOData(const AudioBus* audio_bus,
- uint32 hardware_delay_bytes,
+ uint32_t hardware_delay_bytes,
double normalized_volume);
private:
static void AudioStreamReadCB(audio_in_h handle,
while (bytes_remaining > 0) {
int frames_filled = 0;
if (source_callback_) {
- frames_filled =
- source_callback_->OnMoreData(audio_bus_.get(),
- static_cast<int>(params_.GetBufferDuration().InSeconds() *
- channel_count));
+ frames_filled = source_callback_->OnMoreData(
+ audio_bus_.get(),
+ static_cast<int>(params_.GetBufferDuration().InSeconds() *
+ channel_count),
+ 0);
}
memset(buffer_, 0, bytes_to_fill);
int audio_channels;
int audio_sampling_rate;
bool is_audio_encrypted;
- std::vector<uint8> audio_extra_data;
+ std::vector<uint8_t> audio_extra_data;
VideoCodec video_codec;
gfx::Size video_size;
bool is_video_encrypted;
- std::vector<uint8> video_extra_data;
+ std::vector<uint8_t> video_extra_data;
int duration_ms;
};
class MEDIA_EXPORT MediaPlayerEfl {
public:
typedef struct range {
- int64 start;
- int64 end;
+ int64_t start;
+ int64_t end;
} TimeRanges;
static MediaPlayerEfl* CreatePlayer(
virtual void OnNewFrameAvailable(
int player_id,
base::SharedMemoryHandle handle,
- uint32 length,
+ uint32_t length,
base::TimeDelta timestamp) = 0;
#if defined(TIZEN_TBM_SUPPORT)
virtual void OnNewTbmBufferAvailable(
media_packet_destroy(ptr);
}
-double ConvertNanoSecondsToSeconds(int64 time) {
+double ConvertNanoSecondsToSeconds(int64_t time) {
return base::TimeDelta::FromMicroseconds(
time /
base::Time::kNanosecondsPerMicrosecond).InSecondsF();
#ifndef MEDIA_BASE_EFL_MEDIA_PLAYER_UTIL_EFL_H_
#define MEDIA_BASE_EFL_MEDIA_PLAYER_UTIL_EFL_H_
-#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "media/base/media_export.h"
#include "url/gurl.h"
std::string GetErrorString(int capi_player_error);
MediaError GetMediaError(int capi_player_error);
-double ConvertNanoSecondsToSeconds(int64 time);
+double ConvertNanoSecondsToSeconds(int64_t time);
double ConvertMilliSecondsToSeconds(int time);
double ConvertSecondsToMilliSeconds(double time);
#include <string>
-#include "base/basictypes.h"
#include "base/memory/shared_memory.h"
#include "media/base/media_export.h"
#include <player_internal.h>
-#include "base/basictypes.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "base/thread_task_runner_handle.h"
manager);
}
-MediaSourcePlayerCapi::MediaSourcePlayerCapi(
- int player_id, scoped_ptr<DemuxerEfl> demuxer,
- MediaPlayerManager* manager)
+MediaSourcePlayerCapi::MediaSourcePlayerCapi(int player_id,
+ scoped_ptr<DemuxerEfl> demuxer,
+ MediaPlayerManager* manager)
: MediaPlayerEfl(player_id, manager),
- demuxer_(demuxer.Pass()),
+ demuxer_(std::move(demuxer)),
task_runner_(base::ThreadTaskRunnerHandle::Get()),
weak_this_(this),
player_(NULL),
#include "media/base/tizen/webaudio_decoder_browser_capi.h"
-#include "base/basictypes.h"
#include "base/bind.h"
#include "base/logging.h"
#include "media/base/efl/webaudio_media_codec_info_efl.h"
#include <player.h>
#include <player_internal.h>
-#include "base/basictypes.h"
#include "base/memory/singleton.h"
#include "base/memory/shared_memory.h"
#include "base/threading/thread.h"
DCHECK_EQ(worker_.message_loop(), base::MessageLoop::current());
- client_ = client.Pass();
+ client_ = std::move(client);
if (CAMERA_ERROR_NONE !=
camera_create(DeviceNameToCameraId(device_name_), &camera_)) {
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include "config.h"
#include "RenderThemeChromiumTizen.h"
#include "TizenUserAgentStyleSheets.h"
// FFTFrame implementation using the GStreamer FFT library.
#include "config.h"
+#include "wtf/build_config.h"
#if ENABLE(WEB_AUDIO)
}
}
-uint64 ClipboardEfl::GetSequenceNumber(ClipboardType /* type */) const {
+uint64_t ClipboardEfl::GetSequenceNumber(ClipboardType /* type */) const {
DCHECK(CalledOnValidThread());
// TODO: implement this. For now this interface will advertise
// that the clipboard never changes. That's fine as long as we
}
void ClipboardEfl::ReadHTML(ClipboardType type, string16* markup,
- std::string* src_url, uint32* fragment_start,
- uint32* fragment_end) const {
+ std::string* src_url, uint32_t* fragment_start,
+ uint32_t* fragment_end) const {
DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
int count = ClipboardHelperEfl::GetInstance()->NumberOfItems();
if (format == ELM_SEL_FORMAT_HTML) {
markup->clear();
markup->assign(base::UTF8ToUTF16(clipboard_data));
- *fragment_end = static_cast<uint32>(markup->size());
+ *fragment_end = static_cast<uint32_t>(markup->size());
break;
}
}
~ClipboardEfl() override;
// Clipboard overrides:
- uint64 GetSequenceNumber(ClipboardType type) const override;
+ uint64_t GetSequenceNumber(ClipboardType type) const override;
bool IsFormatAvailable(const FormatType& format,
ClipboardType type) const override;
void Clear(ClipboardType type) override;
void ReadHTML(ClipboardType type,
base::string16* markup,
std::string* src_url,
- uint32* fragment_start,
- uint32* fragment_end) const override;
+ uint32_t* fragment_start,
+ uint32_t* fragment_end) const override;
void ReadRTF(ClipboardType type, std::string* result) const override;
SkBitmap ReadImage(ClipboardType type) const override;
void ReadBookmark(base::string16* title, std::string* url) const override;
#include <Ecore.h>
#include "ecore_x_wayland_wrapper.h"
-#include "base/basictypes.h"
#include "base/memory/singleton.h"
#include "ui/base/ui_base_export.h"
#ifndef UI_GFX_DEVICE_DISPLAY_INFO_EFL_H_
#define UI_GFX_DEVICE_DISPLAY_INFO_EFL_H_
-#include "base/basictypes.h"
#include "base/memory/singleton.h"
#include "base/synchronization/lock.h"
#include "ui/gfx/gfx_export.h"
#endif
}
-const int32* SurfaceFactoryEfl::GetEGLSurfaceProperties(
- const int32* desired_list) {
+const int32_t* SurfaceFactoryEfl::GetEGLSurfaceProperties(
+ const int32_t* desired_list) {
static const EGLint kConfigAttribs[] = {
EGL_BUFFER_SIZE, 32,
EGL_ALPHA_SIZE, 8,
AddGLLibraryCallback add_gl_library,
SetGLGetProcAddressProcCallback set_gl_get_proc_address) override;
intptr_t GetNativeDisplay() override;
- const int32* GetEGLSurfaceProperties(const int32* desired_list) override;
+ const int32_t* GetEGLSurfaceProperties(const int32_t* desired_list) override;
};
} // namespace ui
#include "base/id_map.h"
#include "base/strings/string16.h"
#include "base/compiler_specific.h"
-#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/singleton.h"
#include "components/autofill/core/browser/personal_data_manager_observer.h"
}
void DownloadManagerDelegateEfl::GetNextId(const content::DownloadIdCallback& callback) {
- static uint32 next_id = content::DownloadItem::kInvalidId + 1;
+ static uint32_t next_id = content::DownloadItem::kInvalidId + 1;
callback.Run(next_id++);
}
request.get());
}
+ // if request is suspended, the API takes over the request object lifetime
+ // and request will be deleted after decision is made
if (request->isSuspended())
- request.release();
+ ignore_result(request.release());
else if (!request->isDecided()) // Reject permission if request is not suspended and not decided
callback.Run(PermissionStatus::PERMISSION_STATUS_DENIED);
}
void NotificationControllerEfl::NotificationAdd(uint64_t notification_id,
const GURL& origin, const base::string16& replace_id,
scoped_ptr<DesktopNotificationDelegate> delegate) {
-
- NotificationData* new_notification(new NotificationData(
- origin, replace_id, delegate.Pass()));
+ NotificationData* new_notification(
+ new NotificationData(origin, replace_id, std::move(delegate)));
notifications_map_.AddWithID(new_notification, notification_id);
}
uint64_t notificationUniqueId = reinterpret_cast<uint64_t>(delegate.get());
NotificationAdd(notificationUniqueId, origin,
- base::UTF8ToUTF16(notification_data.tag), delegate.Pass());
+ base::UTF8ToUTF16(notification_data.tag),
+ std::move(delegate));
if (cancel_callback)
*cancel_callback =
void NotificationControllerEfl:: DisplayPersistentNotification(
BrowserContext* browser_context,
- int64 service_worker_registration_id,
+ int64_t service_worker_registration_id,
const GURL& origin,
const SkBitmap& icon,
const PlatformNotificationData& notification_data) {
blink::WebNotificationPermissionDefault) {
web_view->InvokeNotificationPermissionCallback(
notification_permission.get());
+ // if policy is suspended, the API takes over the policy object lifetime
+ // and policy will be deleted after decision is made
if (notification_permission->IsSuspended()) {
- notification_permission.release();
+ ignore_result(notification_permission.release());
return;
}
} else {
const base::string16 replace_id;
scoped_ptr<DesktopNotificationDelegate> notification_delegate;
- NotificationData(const GURL& origin, const base::string16& replaceid,
- scoped_ptr<DesktopNotificationDelegate> delegate)
- : origin_url(origin.spec())
- , replace_id(replaceid)
- , notification_delegate(delegate.Pass()) {
- }
+ NotificationData(const GURL& origin,
+ const base::string16& replaceid,
+ scoped_ptr<DesktopNotificationDelegate> delegate)
+ : origin_url(origin.spec()),
+ replace_id(replaceid),
+ notification_delegate(std::move(delegate)) {}
};
class NotificationControllerEfl: public PlatformNotificationService {
// the user. This method must be called on the UI thread.
void DisplayPersistentNotification(
BrowserContext* browser_context,
- int64 service_worker_registration_id,
+ int64_t service_worker_registration_id,
const GURL& origin,
const SkBitmap& icon,
const PlatformNotificationData& notification_data) override;
#if defined(TIZEN_AUTOFILL_SUPPORT)
-#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "components/password_manager/content/browser/content_password_manager_driver_factory.h"
#include "components/password_manager/content/browser/content_password_manager_driver.h"
#if defined(TIZEN_AUTOFILL_SUPPORT)
-#include "base/basictypes.h"
#include "base/memory/singleton.h"
#include "components/password_manager/core/browser/password_manager_driver.h"
using web_contents_utils::WebViewFromWebContents;
using content::BrowserThread;
-const uint32 kFilteredMessageClasses[] = {
+const uint32_t kFilteredMessageClasses[] = {
EwkMsgStart,
ChromeMsgStart,
};
const std::string& /*user_agent*/,
const std::string& /*content_disposition*/,
const std::string& /*mime_type*/,
- int64 /*content_length*/) {
+ int64_t /*content_length*/) {
WebContents* web_contents = WebContentsFromViewID(
render_process_id, render_view_id);
std::string user_agent;
std::string content_disposition;
std::string mime_type;
- int64 content_length = request->GetExpectedContentSize();
+ int64_t content_length = request->GetExpectedContentSize();
request->extra_request_headers().GetHeader(
net::HttpRequestHeaders::kUserAgent, &user_agent);
const std::string& user_agent,
const std::string& content_disposition,
const std::string& mime_type,
- int64 content_length,
+ int64_t content_length,
int render_process_id,
int render_view_id) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
const std::string& user_agent,
const std::string& content_disposition,
const std::string& mime_type,
- int64 content_length,
+ int64_t content_length,
int render_process_id,
int render_view_id);
};
CacheParamsEfl WebCacheManagerEfl::GetCacheParamsFromModel(Ewk_Cache_Model cache_model)
{
- int64 mem_size = base::SysInfo::AmountOfPhysicalMemory();
+ int64_t mem_size = base::SysInfo::AmountOfPhysicalMemory();
// in chromium the limiting parameter is max file size of network cache
// which is set at the time of creation of backend.
// backend could be completely in-memory as well.
// in WK2/Tizen, it is free space on disk
// So, we are using free space available on browser_context path
// we dont set it on renderer side anyway.
- int64 disk_free_size = base::SysInfo::AmountOfFreeDiskSpace(browser_context_->GetPath());
- int64 cache_min_dead_capacity = 0;
- int64 cache_max_dead_capacity = 0;
- int64 cache_total_capacity = 0;
+ int64_t disk_free_size = base::SysInfo::AmountOfFreeDiskSpace(browser_context_->GetPath());
+ int64_t cache_min_dead_capacity = 0;
+ int64_t cache_max_dead_capacity = 0;
+ int64_t cache_total_capacity = 0;
double dead_decoded_data_deletion_interval = 0;
- int64 page_cache_capacity = 0;
+ int64_t page_cache_capacity = 0;
- int64 url_cache_memory_capacity = 0;
- int64 url_cache_disk_capacity = 0;
+ int64_t url_cache_memory_capacity = 0;
+ int64_t url_cache_disk_capacity = 0;
// We have taken this calculation from WK2.
// Except that, we are using pointers instead of reference for output.
// taken from WK2/Tizen
// static
-void WebCacheManagerEfl::CalculateCacheSizes(Ewk_Cache_Model cache_model, int64 memory_size, int64 disk_free_size,
- int64* cache_total_capacity, int64* cache_min_dead_capacity,
- int64* cache_max_dead_capacity, double* dead_decoded_data_deletion_interval,
- int64* page_cache_capacity, int64* url_cache_memory_capacity,
- int64* url_cache_disk_capacity)
+void WebCacheManagerEfl::CalculateCacheSizes(Ewk_Cache_Model cache_model, int64_t memory_size, int64_t disk_free_size,
+ int64_t* cache_total_capacity, int64_t* cache_min_dead_capacity,
+ int64_t* cache_max_dead_capacity, double* dead_decoded_data_deletion_interval,
+ int64_t* page_cache_capacity, int64_t* url_cache_memory_capacity,
+ int64_t* url_cache_disk_capacity)
{
switch (cache_model) {
case EWK_CACHE_MODEL_DOCUMENT_VIEWER: {
// This code is here to avoid a PLT regression. We can remove it if we
// can prove that the overall system gain would justify the regression.
- *cache_max_dead_capacity = std::max(static_cast<int64>(24), *cache_max_dead_capacity);
+ *cache_max_dead_capacity = std::max(static_cast<int64_t>(24), *cache_max_dead_capacity);
*dead_decoded_data_deletion_interval = 60;
void SetBrowserContext(content::BrowserContext* browser_context);
private:
- static void CalculateCacheSizes(Ewk_Cache_Model cache_model, int64 memory_size, int64 disk_free_size,
- int64* cache_total_capacity, int64* cache_min_dead_capacity,
- int64* cache_max_dead_capacity, double* dead_decoded_data_deletion_interval,
- int64* page_cache_capacity, int64* url_cache_memory_capacity,
- int64* url_cache_disk_capacity);
+ static void CalculateCacheSizes(Ewk_Cache_Model cache_model, int64_t memory_size, int64_t disk_free_size,
+ int64_t* cache_total_capacity, int64_t* cache_min_dead_capacity,
+ int64_t* cache_max_dead_capacity, double* dead_decoded_data_deletion_interval,
+ int64_t* page_cache_capacity, int64_t* url_cache_memory_capacity,
+ int64_t* url_cache_disk_capacity);
CacheParamsEfl GetCacheParamsFromModel(Ewk_Cache_Model);
void SetRenderProcessCacheModel(Ewk_Cache_Model model, int render_process_id);
using namespace web_contents_utils;
namespace {
-static const uint32 kFilteredMessageClasses[] = { EwkMsgStart, ViewMsgStart };
+static const uint32_t kFilteredMessageClasses[] = { EwkMsgStart, ViewMsgStart };
}
class WebViewBrowserMessageFilterPrivate
#if defined(TIZEN_AUTOFILL_SUPPORT)
-#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/memory/singleton.h"
#include "components/webdata/common/web_database_service.h"
pref_registry->RegisterBooleanPref(kAutofillEnabled, true);
pref_registry->RegisterBooleanPref(kAutofillWalletSyncExperimentEnabled, false);
pref_registry->RegisterBooleanPref(kAutofillWalletImportEnabled, true);
- pref_registry->RegisterDoublePref(kAutofillPositiveUploadRate, 0.0);
- pref_registry->RegisterDoublePref(kAutofillNegativeUploadRate, 0.0);
pref_registry->RegisterBooleanPref(kPasswordManagerSavingEnabled, true);
base::PrefServiceFactory pref_service_factory;
pref_service_factory.set_user_prefs(make_scoped_refptr(new AwPrefStore));
pref_service_factory.set_read_error_callback(base::Bind(&HandleReadError));
- user_pref_service_ = pref_service_factory.Create(pref_registry).Pass();
+ user_pref_service_ = std::move(pref_service_factory.Create(pref_registry));
user_prefs::UserPrefs::Set(this, user_pref_service_.get());
}
request_context_getter_ = new URLRequestContextGetterEfl(
- network_delegate_for_getter_.Pass(),
- false,
- cache_base_path,
+ std::move(network_delegate_for_getter_), false, cache_base_path,
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
- protocol_handlers,
- request_interceptors.Pass(),
- NULL);
+ protocol_handlers, std::move(request_interceptors), NULL);
web_context_->cookieManager()->SetRequestContextGetter(
request_context_getter_);
resource_context_->set_url_request_context_getter(
#ifndef CONTENT_BROWSER_MAIN_PARTS_EFL_H_
#define CONTENT_BROWSER_MAIN_PARTS_EFL_H_
-#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "content/public/browser/browser_main_parts.h"
#ifndef CACHE_PARAMS_EFL_H_
#define CACHE_PARAMS_EFL_H_
-#include "base/basictypes.h"
-
struct CacheParamsEfl {
- int64 cache_total_capacity;
- int64 cache_min_dead_capacity;
- int64 cache_max_dead_capacity;
+ int64_t cache_total_capacity;
+ int64_t cache_min_dead_capacity;
+ int64_t cache_max_dead_capacity;
#if 0
double dead_decoded_data_deletion_interval;
int64 page_cache_capacity;
#include "common/content_client_efl.h"
-#include "base/basictypes.h"
#include "common/version_info.h"
#include "ipc/ipc_message.h"
#include "ui/base/resource/resource_bundle.h"
#include <vector>
-#include "base/basictypes.h"
#include "base/files/file_path.h"
#include "base/memory/shared_memory.h"
#include "printing/printing_export.h"
struct DidPrintPagesParams {
base::SharedMemoryHandle metafile_data_handle;
- uint32 data_size;
+ uint32_t data_size;
int document_cookie;
base::FilePath filename;
};
#include "common/version_info.h"
-#if OS(TIZEN)
+#if defined(OS_TIZEN)
#if !TIZEN_VERSION_EQ(2,3,0)
#include "system_info.h"
#else
#include <string>
-#include "base/basictypes.h"
#include "base/memory/scoped_ptr.h"
#include "build/tizen_version.h"
BrowserContext* browser_context,
ProtocolHandlerMap* protocol_handlers,
URLRequestInterceptorScopedVector request_interceptors) {
- return static_cast<BrowserContextEfl*>(browser_context)->
- CreateRequestContext(protocol_handlers, request_interceptors.Pass());
+ return static_cast<BrowserContextEfl*>(browser_context)
+ ->CreateRequestContext(protocol_handlers,
+ std::move(request_interceptors));
}
AccessTokenStore* ContentBrowserClientEfl::CreateAccessTokenStore() {
}
void ContentBrowserClientEfl::AllowCertificateError(
- int render_process_id, int render_frame_id, int cert_error,
- const net::SSLInfo& ssl_info, const GURL& request_url,
- ResourceType resource_type, bool overridable,
- bool strict_enforcement, bool expired_previous_decision,
+ content::WebContents* web_contents,
+ int cert_error,
+ const net::SSLInfo& ssl_info,
+ const GURL& request_url,
+ ResourceType resource_type,
+ bool overridable,
+ bool strict_enforcement,
+ bool expired_previous_decision,
const base::Callback<void(bool)>& callback,
CertificateRequestResultType* result) {
-
- WebContents* web_contents = WebContentsFromFrameID(render_process_id, render_frame_id);
- if (!web_contents) {
- NOTREACHED();
- return;
- }
+ DCHECK(web_contents);
WebContentsDelegate * delegate = web_contents->GetDelegate();
if (!delegate) {
callback.Run(NULL);
render_frame_id);
}
-bool ContentBrowserClientEfl::AllowSetCookie(const GURL& url,
- const GURL& first_party,
- const std::string& cookie_line,
- content::ResourceContext* context,
- int render_process_id,
- int render_frame_id,
- net::CookieOptions* options) {
+bool ContentBrowserClientEfl::AllowSetCookie(
+ const GURL& url,
+ const GURL& first_party,
+ const std::string& cookie_line,
+ content::ResourceContext* context,
+ int render_process_id,
+ int render_frame_id,
+ const net::CookieOptions& options) {
BrowserContextEfl::ResourceContextEfl* rc =
static_cast<BrowserContextEfl::ResourceContextEfl*>(context);
if (!rc)
QuotaPermissionContext* CreateQuotaPermissionContext() override;
- virtual void AllowCertificateError(int render_process_id,
- int render_frame_id,
- int cert_error,
- const net::SSLInfo& ssl_info,
- const GURL& request_url,
- ResourceType resource_type,
- bool overridable,
- bool strict_enforcement,
- bool expired_previous_decision,
- const base::Callback<void(bool)>& callback,
- CertificateRequestResultType* result) override;
+ virtual void AllowCertificateError(
+ WebContents* web_contents,
+ int cert_error,
+ const net::SSLInfo& ssl_info,
+ const GURL& request_url,
+ ResourceType resource_type,
+ bool overridable,
+ bool strict_enforcement,
+ bool expired_previous_decision,
+ const base::Callback<void(bool)>& callback,
+ CertificateRequestResultType* result) override;
#if defined(ENABLE_NOTIFICATIONS)
virtual PlatformNotificationService* GetPlatformNotificationService() override;
content::ResourceContext* context,
int render_process_id,
int render_frame_id,
- net::CookieOptions* options) override;
+ const net::CookieOptions& options) override;
virtual void OverrideWebkitPrefs(content::RenderViewHost* render_view_host,
content::WebPreferences* prefs) override;
dl_params->set_file_path(fullPath);
dl_params->set_prompt(true);
dl_params->set_callback(callback);
- dlm->DownloadUrl(dl_params.Pass());
+ dlm->DownloadUrl(std::move(dl_params));
return fullPath;
}
content::ResourceContext* context,
int render_process_id,
int render_frame_id,
- net::CookieOptions* options) {
+ const net::CookieOptions& options) {
return AllowCookies(url, first_party, true);
}
#include <queue>
#include "url_request_context_getter_efl.h"
-#include "base/basictypes.h"
#include "base/memory/ref_counted.h"
#include "base/synchronization/lock.h"
#include "net/url_request/url_request_context.h"
content::ResourceContext* context,
int render_process_id,
int render_frame_id,
- net::CookieOptions* options);
+ const net::CookieOptions& options);
bool ShouldBlockThirdPartyCookies();
//This is synchronous call
std::string GetCookiesForURL(const std::string& url);
// Copy of internal class implementation from
// content/shell/browser/shell_devtools_delegate.cc
-const uint16 kMinTetheringPort = 9333;
-const uint16 kMaxTetheringPort = 9444;
+const uint16_t kMinTetheringPort = 9333;
+const uint16_t kMaxTetheringPort = 9444;
const int kBackLog = 10;
class TCPServerSocketFactory
: public DevToolsHttpHandler::ServerSocketFactory {
public:
- TCPServerSocketFactory(const std::string& address, uint16 port)
+ TCPServerSocketFactory(const std::string& address, uint16_t port)
: address_(address),
port_(port) {}
}
std::string address_;
- uint16 port_;
+ uint16_t port_;
};
} // namespace
scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> factory(
new TCPServerSocketFactory(addr, port_));
- devtools_http_handler_.reset(
- new devtools_http_handler::DevToolsHttpHandler(factory.Pass(),
- std::string(), this, base::FilePath(),
- base::FilePath(),
- EflWebView::VersionInfo::GetInstance()->ProductNameAndVersionForUserAgent(),
- EflWebView::VersionInfo::GetInstance()->DefaultUserAgent()));
+ devtools_http_handler_.reset(new devtools_http_handler::DevToolsHttpHandler(
+ std::move(factory), std::string(), this, base::FilePath(),
+ base::FilePath(), EflWebView::VersionInfo::GetInstance()
+ ->ProductNameAndVersionForUserAgent(),
+ EflWebView::VersionInfo::GetInstance()->DefaultUserAgent()));
}
DevToolsDelegateEfl::~DevToolsDelegateEfl() {
#define DEVTOOLS_DELEGATE_EFL_H_
-#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "components/devtools_http_handler/devtools_http_handler_delegate.h"
#ifndef DEVTOOLS_MANAGER_DELEGATE_EFL_H_
#define DEVTOOLS_MANAGER_DELEGATE_EFL_H_
-
-#include "base/basictypes.h"
#include "components/devtools_discovery/devtools_target_descriptor.h"
#include "content/public/browser/devtools_manager_delegate.h"
Ewk_Web_Application_Cache_Usage_For_Origin_Get_Callback callback,
void* user_data,
storage::QuotaStatusCode status_code,
- int64 usage,
- int64 quota) {
+ int64_t usage,
+ int64_t quota) {
if (status_code != storage::kQuotaStatusOk) {
LOG(ERROR) << "Error in retrieving usage information";
// We still trigger callback.
if (!entryCount)
return true;
- ScopedVector<content::NavigationEntry> scopedEntries =
- sessions::ContentSerializedNavigationBuilder::ToNavigationEntries(serializedEntries, context()->browser_context());
+ std::vector<scoped_ptr<content::NavigationEntry>> scopedEntries =
+ sessions::ContentSerializedNavigationBuilder::ToNavigationEntries(
+ serializedEntries, context()->browser_context());
NavigationController &navigationController = web_contents_->GetController();
#include <string>
-#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "net/url_request/http_user_agent_settings.h"
#ifndef _NETWORK_DELEGATE_EFL_H_
#define _NETWORK_DELEGATE_EFL_H_
-#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "net/base/network_delegate_impl.h"
#include "cookie_manager.h"
Name: chromium-ewk
Description: EWK API based on chromium-efl engine
-Version: 48.2564.0.51-1
+Version: 49.2623.0.8-1
Requires: chromium-efl
Libs: -L${libdir} -lchromium-ewk
Cflags: -I${includedir}/chromium-ewk
extern "C" {
#endif
-// #if OS(TIZEN)
/// Represents types of gesture.
enum _Ewk_Gesture_Type {
EWK_GESTURE_TAP,
};
/// Creates a type name for @a _Ewk_Gesture_Type.
typedef enum _Ewk_Gesture_Type Ewk_Gesture_Type;
-// #endif // #if OS(TIZEN)
//#if ENABLE(TIZEN_ORIENTATION_EVENTS)
enum _Ewk_Screen_Orientation {
EINA_SAFETY_ON_NULL_RETURN_VAL(request, 0);
return static_cast<const Ewk_Security_Origin*>(request->Origin());
+#else
+ return nullptr;
#endif
}
#include <string>
-#include "base/basictypes.h"
#include "content/public/renderer/render_view_observer.h"
#if !defined(EWK_BRINGUP)
#include "third_party/WebKit/public/web/WebEditorClient.h"
metafile.FinishDocument();
// Get the size of the resulting metafile.
- uint32 buf_size = metafile.GetDataSize();
+ uint32_t buf_size = metafile.GetDataSize();
DCHECK_GT(buf_size, 0u);
DidPrintPagesParams printed_page_params;
return false;
printing::MetafileSkiaWrapper::SetMetafileOnCanvas(*canvas, metafile);
- skia::SetIsDraftMode(*canvas, true);
frame->printPage(params.page_number, canvas);
// Done printing. Close the device context to retrieve the compiled metafile.
#include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
// XXX: config.h needs to be included before internal blink headers.
// XXX2: It'd be great if we did not include internal blibk headers.
-#include "third_party/WebKit/Source/config.h"
#include "third_party/WebKit/Source/platform/fonts/FontCache.h"
using blink::WebCache;
#include "third_party/WebKit/public/web/WebHitTestResult.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
#include "third_party/WebKit/public/web/WebLocalFrame.h"
-#include "third_party/WebKit/public/web/WebPageSerializer.h"
#include "third_party/WebKit/public/web/WebView.h"
#include "third_party/WebKit/public/web/WebSettings.h"
// XXX: config.h needs to be included before internal blink headers.
// It'd be great if we did not include not internal blibk headers.
-#include "third_party/WebKit/Source/config.h"
#include "third_party/WebKit/Source/platform/fonts/FontCache.h"
using blink::WebDataSource;
typedef blink::WebContentSecurityPolicyType SecurityPolicyType;
-COMPILE_ASSERT(
- int(SecurityPolicyType::WebContentSecurityPolicyTypeReport) ==
- int(EWK_REPORT_ONLY), mismatching_enums);
-COMPILE_ASSERT(
- int(SecurityPolicyType::WebContentSecurityPolicyTypeEnforce) ==
- int(EWK_ENFORCE_POLICY), mismatching_enums);
+static_assert(
+ static_cast<int>(SecurityPolicyType::WebContentSecurityPolicyTypeReport) ==
+ static_cast<int>(EWK_REPORT_ONLY),
+ "mismatching enums : EWK_REPORT_ONLY");
+static_assert(
+ static_cast<int>(SecurityPolicyType::WebContentSecurityPolicyTypeEnforce) ==
+ static_cast<int>(EWK_ENFORCE_POLICY),
+ "mismatching enums : EWK_ENFORCE_POLICY");
SecurityPolicyType ToSecurityPolicyType(Ewk_CSP_Header_Type type) {
return static_cast<SecurityPolicyType>(type);
return;
std::string content_string;
+#if !defined(EWK_BRINGUP)
+#pragma message "[M49] WebPageSerializer has been removed from blink. Check for alternative."
blink::WebCString content = blink::WebPageSerializer::serializeToMHTML(view);
if (!content.isEmpty())
content_string = content.data();
+#endif
Send(new EwkHostMsg_ReadMHTMLData(render_view()->GetRoutingID(), content_string, callback_id));
}
io_task_runner_(io_task_runner),
file_task_runner_(file_task_runner),
net_log_(net_log),
- network_delegate_(network_delegate.Pass()),
- request_interceptors_(request_interceptors.Pass()),
+ network_delegate_(std::move(network_delegate)),
+ request_interceptors_(std::move(request_interceptors)),
weak_ptr_factory_(this) {
// Must first be created on the UI thread.
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
// TODO(jam): use v8 if possible, look at chrome code.
storage_->set_proxy_service(
net::ProxyService::CreateUsingSystemProxyResolver(
- proxy_config_service_.Pass(),
- 0,
- url_request_context_->net_log()));
+ std::move(proxy_config_service_), 0,
+ url_request_context_->net_log()));
storage_->set_ssl_config_service(new net::SSLConfigServiceDefaults);
storage_->set_http_auth_handler_factory(
}
if (command_line.HasSwitch(switches::kHostResolverRules)) {
scoped_ptr<net::MappedHostResolver> mapped_host_resolver(
- new net::MappedHostResolver(host_resolver.Pass()));
+ new net::MappedHostResolver(std::move(host_resolver)));
mapped_host_resolver->SetRulesFromString(
command_line.GetSwitchValueASCII(switches::kHostResolverRules));
- host_resolver = mapped_host_resolver.Pass();
+ host_resolver = std::move(mapped_host_resolver);
}
// Give |storage_| ownership at the end in case it's |mapped_host_resolver|.
- storage_->set_host_resolver(host_resolver.Pass());
+ storage_->set_host_resolver(std::move(host_resolver));
network_session_params.host_resolver =
url_request_context_->host_resolver();
// Set up interceptors in the reverse order.
scoped_ptr<net::URLRequestJobFactory> top_job_factory =
- job_factory.Pass();
+ std::move(job_factory);
for (URLRequestInterceptorScopedVector::reverse_iterator i =
request_interceptors_.rbegin();
i != request_interceptors_.rend();
++i) {
top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
- top_job_factory.Pass(), make_scoped_ptr(*i)));
+ std::move(top_job_factory), make_scoped_ptr(*i)));
}
request_interceptors_.weak_clear();
delete metafile;
}
-#if defined(OS_TIZEN)
+#if defined(OS_TIZEN) && defined(TIZEN_MULTIMEDIA_SUPPORT)
static const content::MediaStreamDevice*
GetRequestedVideoDevice(const std::string& device_id) {
const content::MediaStreamDevices& video_devices =
.call(media_permission_request.get());
}
+ // if policy is suspended, the API takes over the policy object lifetime
+ // and policy will be deleted after decision is made
if (media_permission_request->IsSuspended())
- media_permission_request.release();
+ ignore_result(media_permission_request.release());
else if (!media_permission_request->IsDecided()) {
callback.Run(MediaStreamDevices(), MEDIA_DEVICE_NOT_SUPPORTED,
scoped_ptr<MediaStreamUI>());
// if policy is suspended, the API takes over the policy object lifetime
// and policy will be deleted after decision is made
if (certificate_policy_decision_->isSuspended()) {
- certificate_policy_decision_.release();
+ ignore_result(certificate_policy_decision_.release());
} else {
certificate_policy_decision_->setDecision(true);
}
}
bool WebContentsDelegateEfl::AddMessageToConsole(WebContents* source,
- int32 level,
+ int32_t level,
const string16& message,
- int32 line_no,
+ int32_t line_no,
const string16& source_id) {
scoped_ptr<_Ewk_Console_Message> console_message(new _Ewk_Console_Message(level,
UTF16ToUTF8(message).c_str(),
void RenderViewCreated(RenderViewHost* render_view_host) override;
void RenderProcessGone(base::TerminationStatus status) override;
bool AddMessageToConsole(WebContents* source,
- int32 level,
+ int32_t level,
const base::string16& message,
- int32 line_no,
+ int32_t line_no,
const base::string16& source_id) override;
void RunFileChooser(WebContents* web_contents,
const FileChooserParams& params) override;
if (pd->isSuspended()) {
// it will be deleted later after it's used/ignored/downloaded
- pd.release();
+ ignore_result(pd.release());
} else if (!pd->isDecided()) {
pd->Use();
}
<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="48.2564.0.51">
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="49.2623.0.8">
<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="48.2564.0.51">
+<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.chromium-efl" version="49.2623.0.8">
<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="48.2564.0.51"
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="49.2623.0.8"
<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="48.2564.0.51">
+<manifest xmlns="http://tizen.org/ns/packages" api-version="3.0" package="org.tizen.chromium-efl" version="49.2623.0.8">
<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="48.2564.0.51">
+<manifest xmlns="http://tizen.org/ns/packages" package="chromium-efl" version="49.2623.0.8">
<label>uBrowser application for chromium-efl package</label>
<author href="www.samsung.com" email="p.tworek@samsung.com">SRPOL</author>
<description>Small reference browser application for chromium-efl port</description>
%define _binary_payload w3.gzdio
Name: chromium-efl-libs
-%define ChromiumVersion 48.2564.0
-%define Week 51
+%define ChromiumVersion 49.2623.0
+%define Week 8
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 48.2564.0
-%define Week 51
+%define ChromiumVersion 49.2623.0
+%define Week 8
Version: %{ChromiumVersion}.%{Week}
Release: 1
# The 'Group' should be specified as one of the following valid group list.
BuildRequires: pkgconfig(icu-i18n)
BuildRequires: pkgconfig(libdrm)
BuildRequires: pkgconfig(libexif)
+BuildRequires: pkgconfig(libffi)
BuildRequires: pkgconfig(libpci)
BuildRequires: pkgconfig(libpng)
BuildRequires: pkgconfig(libpulse)
%define _binary_payload w3.gzdio
Name: crosswalk-bin
-Version: 15.48.2564.0
+Version: 15.49.2623.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>48.2564.0.51</Version>
+ <Version>49.2623.0.8</Version>
<Type>C++App</Type>
<Descriptions>
<Description Locale="eng-PH"/>