JavaScriptDialogManagerEfl();
~JavaScriptDialogManagerEfl() override;
+ JavaScriptDialogManagerEfl(const JavaScriptDialogManagerEfl&) = delete;
+ JavaScriptDialogManagerEfl& operator=(const JavaScriptDialogManagerEfl&) =
+ delete;
+
// Displays a JavaScript dialog. |did_suppress_message| will not be nil; if
// |true| is returned in it, the caller will handle faking the reply.
void RunJavaScriptDialog(WebContents* web_contents,
private:
std::map<WebContents*, JavaScriptModalDialogEfl*> open_dialogs_;
-
- // DISALLOW_COPY_AND_ASSIGN(JavaScriptDialogManagerEfl);
};
} // namespace content
class CONTENT_EXPORT BrowserMediaPacketManager : public BrowserMessageFilter {
public:
BrowserMediaPacketManager();
+
+ BrowserMediaPacketManager(const BrowserMediaPacketManager&) = delete;
+ BrowserMediaPacketManager& operator=(const BrowserMediaPacketManager&) =
+ delete;
+
bool OnMessageReceived(const IPC::Message& message) override;
protected:
private:
void ReleaseMediaPacket(gfx::TbmBufferHandle packet);
-
- // DISALLOW_COPY_AND_ASSIGN(BrowserMediaPacketManager);
};
} // namespace content
demuxer_->RemoveDemuxerClient(demuxer_client_id_);
}
+ Internal(const Internal&) = delete;
+ Internal& operator=(const Internal&) = delete;
+
// |media::DemuxerEfl| implementation.
void Initialize(media::DemuxerEflClient* client) override {
DCHECK(!ClientIDExists()) << demuxer_client_id_;
scoped_refptr<BrowserDemuxerEfl> demuxer_;
int demuxer_client_id_;
-
- // DISALLOW_COPY_AND_ASSIGN(Internal);
};
scoped_refptr<BrowserMessageFilter> CreateBrowserDemuxerEfl() {
public:
BrowserDemuxerEfl();
+ BrowserDemuxerEfl(const BrowserDemuxerEfl&) = delete;
+ BrowserDemuxerEfl& operator=(const BrowserDemuxerEfl&) = delete;
+
// BrowserMessageFilter overrides.
void OverrideThreadForMessage(
const IPC::Message& message,
const base::TimeDelta& duration);
IDMap<media::DemuxerEflClient> demuxer_clients_;
-
- // DISALLOW_COPY_AND_ASSIGN(BrowserDemuxerEfl);
};
} // namespace content
static BrowserMediaPlayerManagerEfl* Create(RenderFrameHost* rfh);
~BrowserMediaPlayerManagerEfl() override;
+ BrowserMediaPlayerManagerEf(const BrowserMediaPlayerManagerEf&) = delete;
+ BrowserMediaPlayerManagerEf& operator=(const BrowserMediaPlayerManagerEf&) =
+ delete;
+
// media::MediaPlayerManager implementation.
media::MediaPlayerEfl* GetPlayer(int player_id) override;
void OnTimeChanged(int player_id) override;
// A queue to initialize player including preroll.
std::deque<int> init_queue_;
std::deque<int> resumed_queue_;
-
- // DISALLOW_COPY_AND_ASSIGN(BrowserMediaPlayerManagerEfl);
};
} // namespace content
explicit MediaWebContentsObserver(WebContents* web_contents);
virtual ~MediaWebContentsObserver();
+ MediaWebContentsObserver(const MediaWebContentsObserver&) = delete;
+ MediaWebContentsObserver& operator=(const MediaWebContentsObserver&) = delete;
+
// WebContentsObserver implementations.
virtual void RenderFrameDeleted(RenderFrameHost* render_frame_host) override;
virtual bool OnMessageReceived(const IPC::Message& message,
scoped_ptr<BrowserMediaPlayerManagerEfl>>
MediaPlayerManagerMap;
MediaPlayerManagerMap media_player_managers_;
-
- // DISALLOW_COPY_AND_ASSIGN(MediaWebContentsObserver);
};
} // namespace content
ScreenOrientationDelegateEfl();
~ScreenOrientationDelegateEfl() override;
+ ScreenOrientationDelegateEfl(const ScreenOrientationDelegateEfl&) = delete;
+ ScreenOrientationDelegateEfl& operator=(const ScreenOrientationDelegateEfl&) =
+ delete;
+
// ScreenOrientationDelegate:
bool FullScreenRequired(WebContents* web_contents) override;
void Lock(WebContents* web_contents,
device::mojom::ScreenOrientationLockType lock_orientation) override;
bool ScreenOrientationProviderSupported(WebContents* web_contents) override;
void Unlock(WebContents* web_contents) override;
-
- private:
- // DISALLOW_COPY_AND_ASSIGN(ScreenOrientationDelegateEfl);
};
} // namespace content
public base::SupportsWeakPtr<TtsMessageFilterEfl> {
public:
TtsMessageFilterEfl();
+
+ TtsMessageFilterEfl(const TtsMessageFilterEfl&) = delete;
+ TtsMessageFilterEfl& operator=(const TtsMessageFilterEfl&) = delete;
+
// content::BrowserMessageFilter implementation.
void OverrideThreadForMessage(
const IPC::Message& message,
void OnCancel();
std::unique_ptr<TtsTizen> tts_tizen_;
-
- // DISALLOW_COPY_AND_ASSIGN(TtsMessageFilterEfl);
};
} // namespace content
private:
TracingControllerEfl();
+
+ TracingControllerEfl(const TracingControllerEfl&) = delete;
+ TracingControllerEfl& operator=(const TracingControllerEfl&) = delete;
+
void OnTracingStopped();
bool is_tracing_;
base::WeakPtrFactory<TracingControllerEfl> weak_factory_;
std::string trace_file_name_;
-
- // DISALLOW_COPY_AND_ASSIGN(TracingControllerEfl);
};
#endif // IMPL_BROWSER_TRACING_TRACING_CONTROLLER_EFL_H_
WebDragDestEfl(WebContents* web_contents);
~WebDragDestEfl();
+ WebDragDestEfl(const WebDragDestEfl&) = delete;
+ WebDragDestEfl& operator=(const WebDragDestEfl&) = delete;
+
blink::DragOperationsMask GetAction() { return drag_action_; }
WebDragDestDelegate* GetDelegate() const { return delegate_; }
DropData* GetDropData() { return drop_data_.get(); }
// The data for the current drag, or NULL if |context_| is NULL.
std::unique_ptr<DropData> drop_data_;
-
- // DISALLOW_COPY_AND_ASSIGN(WebDragDestEfl);
};
} // namespace content
explicit WebDragSourceEfl(WebContents* web_contents);
virtual ~WebDragSourceEfl();
+ WebDragSourceEfl(const WebDragSourceEfl&) = delete;
+ WebDragSourceEfl& operator=(const WebDragSourceEfl&) = delete;
+
// Starts a drag for the WebContents this object was created for.
// Returns false if the drag could not be started.
bool StartDragging(const DropData& drop_data,
gfx::Point initial_position_;
gfx::Point last_pointer_pos_;
-
- // DISALLOW_COPY_AND_ASSIGN(WebDragSourceEfl);
};
} // namespace content
TizenVideoDecodeAccelerator();
~TizenVideoDecodeAccelerator() override;
+ TizenVideoDecodeAccelerator(const TizenVideoDecodeAccelerator&) = delete;
+ TizenVideoDecodeAccelerator& operator=(const TizenVideoDecodeAccelerator&) =
+ delete;
+
bool Initialize(const Config& config, Client* client) override;
void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
void AssignPictureBuffers(
void StartDecoder();
Impl* impl_;
-
- // DISALLOW_COPY_AND_ASSIGN(TizenVideoDecodeAccelerator);
};
} // namespace content
TizenVideoEncodeAccelerator();
~TizenVideoEncodeAccelerator() override;
+ TizenVideoEncodeAccelerator(const TizenVideoEncodeAccelerator&) = delete;
+ TizenVideoEncodeAccelerator& operator=(const TizenVideoEncodeAccelerator&) =
+ delete;
+
std::vector<media::VideoEncodeAccelerator::SupportedProfile>
GetSupportedProfiles() override;
bool Initialize(media::VideoPixelFormat input_format,
bool StartEncoder();
Impl* impl_;
-
- // DISALLOW_COPY_AND_ASSIGN(TizenVideoEncodeAccelerator);
};
} // namespace content
public:
RendererDemuxerEfl();
+ RendererDemuxerEfl(const RendererDemuxerEfl&) = delete;
+ RendererDemuxerEfl& operator=(const RendererDemuxerEfl&) = delete;
+
// Returns the next available demuxer client ID for use in IPC messages.
//
// Safe to call on any thread.
IDMap<MediaSourceDelegateEfl> delegates_;
scoped_refptr<ThreadSafeSender> thread_safe_sender_;
scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
-
- // DISALLOW_COPY_AND_ASSIGN(RendererDemuxerEfl);
};
} // namespace content
explicit RendererMediaPlayerManager(RenderFrame* render_frame);
~RendererMediaPlayerManager() override;
+ RendererMediaPlayerManager(const RendererMediaPlayerManager&) = delete;
+ RendererMediaPlayerManager& operator=(const RendererMediaPlayerManager&) =
+ delete;
+
// Initializes a MediaPlayerEfl object in browser process.
void Initialize(int player_id, MediaPlayerHostMsg_Initialize_Type type,
const GURL& url, double volume, int demuxer_client_id);
private:
std::map<int, WebMediaPlayerEfl*> media_players_;
int next_media_player_id_;
-
- // DISALLOW_COPY_AND_ASSIGN(RendererMediaPlayerManager);
};
} // namespace content
const media::WebMediaPlayerParams& params);
~WebMediaPlayerEfl() override;
+ WebMediaPlayerEfl(const WebMediaPlayerEfl&) = delete;
+ WebMediaPlayerEfl& operator=(const WebMediaPlayerEfl&) = delete;
+
// blink::WebMediaPlayer implementation.
void load(LoadType load_type,
const blink::WebURL& url,
#if defined(TIZEN_MULTIMEDIA_EME_SUPPORT)
scoped_ptr<media::EncryptedMediaPlayerSupport> encrypted_media_support_;
#endif
-
- // DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerEfl);
};
} // namespace content
public:
AudioDecoderIO(const char* data, size_t data_size);
virtual ~AudioDecoderIO();
+
+ AudioDecoderIO(const AudioDecoderIO&) = delete;
+ AudioDecoderIO& operator=(const AudioDecoderIO&) = delete;
+
bool ShareEncodedDataToProcess(base::SharedMemoryHandle* handle);
// Returns true if |AudioDecoderIO| was successfully created.
// write_fd_ and writes to it.
int read_fd_;
int write_fd_;
-
- // DISALLOW_COPY_AND_ASSIGN(AudioDecoderIO);
};
AudioDecoderIO::AudioDecoderIO(const char* data, size_t data_size)
private:
~TtsDispatcherEfl() override;
+ TtsDispatcherEfl(const TtsDispatcherEfl&) = delete;
+ TtsDispatcherEfl& operator=(const TtsDispatcherEfl&) = delete;
+
// RenderThreadObserver override.
bool OnControlMessageReceived(const IPC::Message& message) override;
// Map from id to utterance objects.
std::map<int, blink::WebSpeechSynthesisUtterance> utterance_id_map_;
-
- // DISALLOW_COPY_AND_ASSIGN(TtsDispatcherEfl);
};
} // namespace content
const BatteryStatusService::BatteryUpdateCallback& callback);
~BatteryStatusManagerTizen() override;
+ BatteryStatusManagerTizen(const BatteryStatusManagerTizen&) = delete;
+ BatteryStatusManagerTizen& operator=(const BatteryStatusManagerTizen&) =
+ delete;
+
BatteryStatus GetCurrentStatus() const { return current_status_; }
void SetCurrentStatus(BatteryStatus status) { current_status_ = status; }
BatteryStatus current_status_;
BatteryStatusService::BatteryUpdateCallback callback_;
-
- // DISALLOW_COPY_AND_ASSIGN(BatteryStatusManagerTizen);
};
} // namespace content
explicit AudioManagerCapi(AudioLogFactory* audio_log_factory);
~AudioManagerCapi() override;
+ AudioManagerCapi(const AudioManagerCapi&) = delete;
+ AudioManagerCapi& operator=(const AudioManagerCapi&) = delete;
+
static AudioManager* Create(AudioLogFactory* audio_log_factory);
// Implementation of AudioManager.
const std::string& device_id);
int native_input_sample_rate_;
-
- // DISALLOW_COPY_AND_ASSIGN(AudioManagerCapi);
};
} // namespace media
~CapiAudioInputStream() override;
+ CapiAudioInputStream(const CapiAudioInputStream&) = delete;
+ CapiAudioInputStream& operator=(const CapiAudioInputStream&) = delete;
+
bool Open() override;
void Start(AudioInputCallback* callback) override;
void Stop() override;
// Holds the data from the OS.
AudioBlockFifo fifo_;
-
- // DISALLOW_COPY_AND_ASSIGN(CapiAudioInputStream);
};
} // namespace media
~CapiAudioOutputStream() override;
+ CapiAudioOutputStream(const CapiAudioOutputStream&) = delete;
+ CapiAudioOutputStream& operator=(const CapiAudioOutputStream&) = delete;
+
bool Open() override;
void Close() override;
void Start(AudioSourceCallback* callback) override;
media::InternalState state_;
AudioSourceCallback* source_callback_;
std::unique_ptr<AudioBus> audio_bus_;
-
- // DISALLOW_COPY_AND_ASSIGN(CapiAudioOutputStream);
};
} // namespace media
protected:
explicit MediaPlayerEfl(int player_id, MediaPlayerManager* manager);
+ MediaPlayerEfl(const MediaPlayerEfl&) = delete;
+ MediaPlayerEfl& operator=(const MediaPlayerEfl&) = delete;
+
// Release the player resources.
virtual void Release() = 0;
MediaPlayerManager* manager() { return manager_; }
// Resource manager for all the media players.
MediaPlayerManager* manager_;
-
- // DISALLOW_COPY_AND_ASSIGN(MediaPlayerEfl);
};
} // namespace media
const std::string& user_agent);
~MediaPlayerBridgeCapi() override;
+ MediaPlayerBridgeCapi(const MediaPlayerBridgeCapi&) = delete;
+ MediaPlayerBridgeCapi& operator=(const MediaPlayerBridgeCapi&) = delete;
+
// MediaPlayerTizen implementation.
void Initialize() override;
void Resume() override;
// NOTE: Weak pointers must be invalidated before all other member variables.
base::WeakPtrFactory<MediaPlayerBridgeCapi> weak_factory_;
-
- // DISALLOW_COPY_AND_ASSIGN(MediaPlayerBridgeCapi);
};
} // namespace media
~MediaSourcePlayerCapi() override;
+ MediaSourcePlayerCapi(const MediaSourcePlayerCapi&) = delete;
+ MediaSourcePlayerCapi& operator=(const MediaSourcePlayerCapi&) = delete;
+
// MediaPlayerEfl implementation.
void Play() override;
void Pause(bool is_media_related_action) override;
std::deque<scoped_refptr<DecoderBuffer> > video_buffer_queue_;
base::WeakPtrFactory<MediaSourcePlayerCapi> weak_factory_;
-
- // DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayerCapi);
};
} // namespace media
static WebAudioDecoderCapi* GetInstance();
virtual ~WebAudioDecoderCapi();
+ WebAudioDecoderCapi(const WebAudioDecoderCapi&) = delete;
+ WebAudioDecoderCapi& operator=(const WebAudioDecoderCapi&) = delete;
+
// media::WebAudioDecoder implementation.
void EncodedDataReceived(base::SharedMemoryHandle memory_handle,
base::FileDescriptor pcm_output,
uint32_t data_size);
base::Thread capi_thread_;
-
- // DISALLOW_COPY_AND_ASSIGN(WebAudioDecoderCapi);
};
class AudioDecoderCapi {
camera_destroy(camera_handle_);
}
+ CameraHandle(const CameraHandle&) = delete;
+ CameraHandle& operator=(const CameraHandle&) = delete;
+
camera_h camera_handle_;
friend struct base::DefaultSingletonTraits<CameraHandle>;
- // DISALLOW_COPY_AND_ASSIGN(CameraHandle);
};
} // namespace
scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
~VideoCaptureDeviceFactoryTizen() override;
+ VideoCaptureDeviceFactoryTizen(const VideoCaptureDeviceFactoryTizen&) =
+ delete;
+ VideoCaptureDeviceFactoryTizen& operator=(
+ const VideoCaptureDeviceFactoryTizen&) = delete;
+
scoped_ptr<VideoCaptureDevice> Create(
const VideoCaptureDevice::Name& device_name) override;
void GetDeviceNames(VideoCaptureDevice::Names* device_names) override;
private:
scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
-
- // DISALLOW_COPY_AND_ASSIGN(VideoCaptureDeviceFactoryTizen);
};
} // namespace media
private:
ClipboardHelperEfl();
+
+ ClipboardHelperEfl(const ClipboardHelperEfl&) = delete;
+ ClipboardHelperEfl& operator=(const ClipboardHelperEfl&) = delete;
+
friend struct base::DefaultSingletonTraits<ClipboardHelperEfl>;
// TODO: Webview TG will implement following for Wayland.
#endif
void clearClipboardHandler();
void initializeAtomList();
- // DISALLOW_COPY_AND_ASSIGN(ClipboardHelperEfl);
Ecore_Event_Handler* m_selectionClearHandler;
Ecore_Event_Handler* m_selectionNotifyHandler;
private:
DeviceDisplayInfoEflImpl();
+
+ DeviceDisplayInfoEflImpl(const DeviceDisplayInfoEflImpl&) = delete;
+ DeviceDisplayInfoEflImpl& operator=(const DeviceDisplayInfoEflImpl&) = delete;
+
void NotifyDeviceDisplayInfoChanged();
friend struct base::DefaultSingletonTraits<DeviceDisplayInfoEflImpl>;
double dip_scale_;
int rotation_degrees_;
base::ObserverList<DeviceDisplayInfoObserverEfl>::Unchecked observer_list_;
-
- // DISALLOW_COPY_AND_ASSIGN(DeviceDisplayInfoEflImpl);
};
// static
public:
explicit DeviceDisplayInfoEfl();
+ DeviceDisplayInfoEfl(const DeviceDisplayInfoEfl&) = delete;
+ DeviceDisplayInfoEfl& operator=(const DeviceDisplayInfoEfl&) = delete;
+
// Update all info.
void Update(int display_width, int display_height, double dip_scale,
int rotation_degrees);
void AddObserver(DeviceDisplayInfoObserverEfl* observer);
void RemoveObserver(DeviceDisplayInfoObserverEfl* observer);
-
- private:
- // DISALLOW_COPY_AND_ASSIGN(DeviceDisplayInfoEfl);
};
} // namespace display
public content::WebContentsObserver {
public:
virtual ~AutofillClientEfl();
+
+ AutofillClientEfl(const AutofillClientEfl&) = delete;
+ AutofillClientEfl& operator=(const AutofillClientEfl&) = delete;
+
// Called when the tab corresponding to |this| instance is activated.
void TabActivated();
// AutofillManagerDelegate implementation.
EWebView* webview_;
scoped_refptr<AutofillWebDataService> database_;
AutofillPopupViewEfl* popup_controller_;
-
- // DISALLOW_COPY_AND_ASSIGN(AutofillClientEfl);
};
} // namespace autofill
PersonalDataManagerFactory();
~PersonalDataManagerFactory();
+ PersonalDataManagerFactory(const PersonalDataManagerFactory&) = delete;
+ PersonalDataManagerFactory& operator=(const PersonalDataManagerFactory&) =
+ delete;
+
IDMap<PersonalDataManager, IDMapOwnPointer> personal_data_manager_id_map_;
- // DISALLOW_COPY_AND_ASSIGN(PersonalDataManagerFactory);
Ewk_Context_Form_Autofill_Profile_Changed_Callback callback_;
void* callback_user_data_;
};
private:
FaviconDatabase();
- // DISALLOW_COPY_AND_ASSIGN(FaviconDatabase);
+
+ FaviconDatabase(const FaviconDatabase&) = delete;
+ FaviconDatabase& operator=(const FaviconDatabase&) = delete;
bool IsOpen() const;
bool Open();
FaviconDownloaderCallback callback);
virtual ~FaviconDownloader() {}
+ FaviconDownloader(const FaviconDownloader&) = delete;
+ FaviconDownloader& operator=(const FaviconDownloader&) = delete;
+
void Start();
private:
GURL m_faviconUrl;
FaviconDownloaderCallback m_callback;
base::WeakPtrFactory<FaviconDownloader> m_weakPtrFactory;
- // DISALLOW_COPY_AND_ASSIGN(FaviconDownloader);
};
#endif // FAVICON_DOWNLOADER_H
private:
LocationProviderEfl();
+
+ LocationProviderEfl(const LocationProviderEfl&) = delete;
+ LocationProviderEfl& operator=(const LocationProviderEfl&) = delete;
+
static void GeoPositionChangedCb(double, double, double, time_t, void*);
void NotifyPositionChanged(double, double, double, time_t);
Geoposition last_position_;
location_manager_h location_manager_;
base::MessageLoop* geolocation_message_loop_;
-
- // DISALLOW_COPY_AND_ASSIGN(LocationProviderEfl);
};
} // namespace content
JavaScriptDialogManagerEfl();
virtual ~JavaScriptDialogManagerEfl();
+ JavaScriptDialogManagerEfl(const JavaScriptDialogManagerEfl&) = delete;
+ JavaScriptDialogManagerEfl& operator=(const JavaScriptDialogManagerEfl&) =
+ delete;
+
// JavaScriptDialogManager:
void RunJavaScriptDialog(content::WebContents* web_contents,
content::RenderFrameHost* render_frame_host,
std::unique_ptr<JavaScriptModalCallbacksData> confirm_callback_data_;
std::unique_ptr<JavaScriptModalCallbacksData> prompt_callback_data_;
DialogClosedCallback dialog_closed_callback_;
-
- // DISALLOW_COPY_AND_ASSIGN(JavaScriptDialogManagerEfl);
};
#endif /* JAVASCRIPT_DIALOG_MANAGER_EFL_H_ */
private:
MimeOverrideManagerEfl() {}
+ MimeOverrideManagerEfl(const MimeOverrideManagerEfl&) = delete;
+ MimeOverrideManagerEfl& operator=(const MimeOverrideManagerEfl&) = delete;
+
friend struct base::DefaultSingletonTraits<MimeOverrideManagerEfl>;
base::Lock lock_;
MimeOverrideMap mime_override_map_;
-
- // DISALLOW_COPY_AND_ASSIGN(MimeOverrideManagerEfl);
};
#endif // MIME_OVERRIDE_MANAGER_EFL_H_
NotificationControllerEfl();
~NotificationControllerEfl() override;
+ NotificationControllerEfl(const NotificationControllerEfl&) = delete;
+ NotificationControllerEfl& operator=(const NotificationControllerEfl&) =
+ delete;
+
void NotificationCancelled(uint64_t notification_id);
bool NotificationClosed(uint64_t notification_id, bool by_user) {
std::unique_ptr<PermissionHandler> permission_handler_;
std::unique_ptr<DefaultCallback> default_callback_;
std::unique_ptr<NotificationHelper> notification_helper_;
-
- // DISALLOW_COPY_AND_ASSIGN(NotificationControllerEfl);
};
} // namespace content
private:
explicit PasswordManagerClientEfl(content::WebContents* web_contents,
autofill::AutofillClient* autofill_client);
+
+ PasswordManagerClientEfl(const PasswordManagerClientEfl&) = delete;
+ PasswordManagerClientEfl& operator=(const PasswordManagerClientEfl&) = delete;
+
friend class content::WebContentsUserData<PasswordManagerClientEfl>;
// This filter does not filter out anything, it is a dummy implementation of
// Allows authentication callbacks to be destroyed when this client is gone.
base::WeakPtrFactory<PasswordManagerClientEfl> weak_factory_;
-
- // DISALLOW_COPY_AND_ASSIGN(PasswordManagerClientEfl);
};
}
explicit PasswordStoreService(scoped_refptr<PasswordStore> password_store);
virtual ~PasswordStoreService();
+ PasswordStoreService(const PasswordStoreService&) = delete;
+ PasswordStoreService& operator=(const PasswordStoreService&) = delete;
+
scoped_refptr<PasswordStore> GetPasswordStore();
private:
scoped_refptr<PasswordStore> password_store_;
- // DISALLOW_COPY_AND_ASSIGN(PasswordStoreService);
};
// Singleton that owns all PasswordStores and associates them with
friend struct base::DefaultSingletonTraits<PasswordStoreFactory>;
PasswordStoreFactory();
virtual ~PasswordStoreFactory();
+
+ PasswordStoreFactory(const PasswordStoreFactory&) = delete;
+ PasswordStoreFactory& operator=(const PasswordStoreFactory&) = delete;
+
void Init();
std::unique_ptr<PasswordStoreService> service_;
-
- // DISALLOW_COPY_AND_ASSIGN(PasswordStoreFactory);
};
}
#endif // TIZEN_AUTOFILL_SUPPORT
SSLHostStateDelegateEfl();
~SSLHostStateDelegateEfl() override;
+ SSLHostStateDelegateEfl(const SSLHostStateDelegateEfl&) = delete;
+ SSLHostStateDelegateEfl& operator=(const SSLHostStateDelegateEfl&) = delete;
+
// Records that |cert| is permitted to be used for |host| in the future, for
// a specified |error| type.
void AllowCert(const std::string& host,
private:
// Certificate policies for each host.
std::map<std::string, internal::CertPolicy> cert_policy_for_host_;
-
- // DISALLOW_COPY_AND_ASSIGN(SSLHostStateDelegateEfl);
};
}
, cancel_vibration_cb_(nullptr)
, user_data_(nullptr) {}
+ VibrationProviderClientEwk(const VibrationProviderClientEwk&) = delete;
+ VibrationProviderClientEwk& operator=(const VibrationProviderClientEwk&) =
+ delete;
+
Ewk_Vibration_Client_Vibrate_Cb vibrate_cb_;
Ewk_Vibration_Client_Vibration_Cancel_Cb cancel_vibration_cb_;
void* user_data_;
-
- // DISALLOW_COPY_AND_ASSIGN(VibrationProviderClientEwk);
};
#endif // Vibration_Provider_Client_h
explicit WebCacheManagerEfl(content::BrowserContext* browser_context);
virtual ~WebCacheManagerEfl();
+ WebCacheManagerEfl(const WebCacheManagerEfl&) = delete;
+ WebCacheManagerEfl& operator=(const WebCacheManagerEfl&) = delete;
+
// content::NotificationObserver implementation:
virtual void Observe(int type,
const content::NotificationSource& source,
std::set<int> renderers_;
content::BrowserContext* browser_context_;
Ewk_Cache_Model cache_model_;
- // DISALLOW_COPY_AND_ASSIGN(WebCacheManagerEfl);
};
#endif
WebDataService();
virtual ~WebDataService();
- private:
- // DISALLOW_COPY_AND_ASSIGN(WebDataService);
+ WebDataService(const WebDataService&) = delete;
+ WebDataService& operator=(const WebDataService&) = delete;
};
#endif // TIZEN_AUTOFILL_SUPPORT
virtual ~WebDataServiceWrapper();
+ WebDataServiceWrapper(const WebDataServiceWrapper&) = delete;
+ WebDataServiceWrapper& operator=(const WebDataServiceWrapper&) = delete;
+
virtual scoped_refptr<autofill::AutofillWebDataService> GetAutofillWebData();
virtual scoped_refptr<WebDataService> GetWebData();
scoped_refptr<autofill::AutofillWebDataService> autofill_web_data_;
scoped_refptr<WebDataService> web_data_;
-
- // DISALLOW_COPY_AND_ASSIGN(WebDataServiceWrapper);
};
// Singleton that owns all WebDataServiceWrappers
WebDataServiceFactory();
virtual ~WebDataServiceFactory();
- // DISALLOW_COPY_AND_ASSIGN(WebDataServiceFactory);
+ WebDataServiceFactory(const WebDataServiceFactory&) = delete;
+ WebDataServiceFactory& operator=(const WebDataServiceFactory&) = delete;
};
#endif // TIZEN_AUTOFILL_SUPPORT
ResourceContextEfl(scoped_refptr<CookieManager> cookie_manager);
~ResourceContextEfl();
+ ResourceContextEfl(const ResourceContextEfl&) = delete;
+ ResourceContextEfl& operator=(const ResourceContextEfl&) = delete;
+
bool HTTPCustomHeaderAdd(const std::string& name, const std::string& value);
bool HTTPCustomHeaderRemove(const std::string& name);
void HTTPCustomHeaderClear();
scoped_refptr<CookieManager> cookie_manager_;
HTTPCustomHeadersEflMap http_custom_headers_;
mutable base::Lock http_custom_headers_lock_;
-
- // DISALLOW_COPY_AND_ASSIGN(ResourceContextEfl);
};
BrowserContextEfl(EWebContext*, bool incognito = false);
~BrowserContextEfl();
+ BrowserContextEfl(const BrowserContextEfl&) = delete;
+ BrowserContextEfl& operator=(const BrowserContextEfl&) = delete;
+
// BrowserContext implementation.
net::URLRequestContextGetter* CreateMediaRequestContext();
net::URLRequestContextGetter* CreateMediaRequestContextForStoragePartition(
std::unique_ptr<SSLHostStateDelegateEfl> ssl_host_state_delegate_;
std::unique_ptr<BackgroundSyncController> background_sync_controller_;
std::unique_ptr<PermissionControllerDelegate> permission_controller_delegate_;
-
- // DISALLOW_COPY_AND_ASSIGN(BrowserContextEfl);
};
}
BrowserMainPartsEfl();
~BrowserMainPartsEfl() override;
+ BrowserMainPartsEfl(const BrowserMainPartsEfl&) = delete;
+ BrowserMainPartsEfl& operator=(const BrowserMainPartsEfl&) = delete;
+
// BrowserMainParts overrides.
int PreMainMessageLoopRun() override;
void PostMainMessageLoopRun() override;
private:
DevToolsDelegateEfl* devtools_delegate_;
-
- // DISALLOW_COPY_AND_ASSIGN(BrowserMainPartsEfl);
};
} // namespace content
VersionInfo();
~VersionInfo() { }
+ VersionInfo(const VersionInfo&) = delete;
+ VersionInfo& operator=(const VersionInfo&) = delete;
+
std::string product_name_;
std::string product_version_;
static VersionInfo* version_info_;
-
- // DISALLOW_COPY_AND_ASSIGN(VersionInfo);
};
} // namespace EflWebView
ContentBrowserClientEfl();
~ContentBrowserClientEfl() override;
+
+ ContentBrowserClientEfl(const ContentBrowserClientEfl&) = delete;
+ ContentBrowserClientEfl& operator=(const ContentBrowserClientEfl&) = delete;
typedef base::OnceCallback<void(const std::string&)>
AcceptLangsChangedCallback;
std::vector<AcceptLangsChangedCallback> accept_langs_changed_callbacks_;
bool shutting_down_ = false;
-
- // DISALLOW_COPY_AND_ASSIGN(ContentBrowserClientEfl);
};
} // namespace content
ContentMainDelegateEfl() = default;
~ContentMainDelegateEfl() override = default;
+ ContentMainDelegateEfl(const ContentMainDelegateEfl&) = delete;
+ ContentMainDelegateEfl& operator=(const ContentMainDelegateEfl&) = delete;
+
// ContentMainDelegate implementation:
absl::optional<int> BasicStartupComplete() override;
void PreSandboxStartup() override;
std::unique_ptr<ContentBrowserClient> browser_client_;
std::unique_ptr<ContentRendererClient> renderer_client_;
ContentClientEfl content_client_;
- // DISALLOW_COPY_AND_ASSIGN(ContentMainDelegateEfl);
};
}
CookieManager();
virtual ~CookieManager();
+
+ CookieManager(const CookieManager&) = delete;
+ CookieManager& operator=(const CookieManager&) = delete;
+
// Delete all cookies that match the specified parameters. If both |url| and
// values |cookie_name| are specified all host and domain cookies matching
// both will be deleted. If only |url| is specified all host cookies (but not
base::WeakPtrFactory<CookieManager> weak_ptr_factory_;
// file scheme
base::Lock file_scheme_lock_;
-
- // DISALLOW_COPY_AND_ASSIGN(CookieManager);
};
#endif //cookie_manager_h
DevToolsManagerDelegateEfl();
~DevToolsManagerDelegateEfl() override;
- private:
- // DISALLOW_COPY_AND_ASSIGN(DevToolsManagerDelegateEfl);
+ DevToolsManagerDelegateEfl(const DevToolsManagerDelegateEfl&) = delete;
+ DevToolsManagerDelegateEfl& operator=(const DevToolsManagerDelegateEfl&) =
+ delete;
};
} // namespace content
EwkGlobalData();
~EwkGlobalData();
+ EwkGlobalData(const EwkGlobalData&) = delete;
+ EwkGlobalData& operator=(const EwkGlobalData&) = delete;
+
static EwkGlobalData* instance_;
#if defined(USE_OZONE)
std::unique_ptr<content::BrowserMainRunner> browser_main_runner_;
scoped_refptr<content::URLRequestContextGetterEfl> system_request_context_;
-
- // DISALLOW_COPY_AND_ASSIGN(EwkGlobalData);
};
#endif // EWK_GLOBAL_DATA_H_
HttpUserAgentSettingsEfl();
~HttpUserAgentSettingsEfl() override;
+ HttpUserAgentSettingsEfl(const HttpUserAgentSettingsEfl&) = delete;
+ HttpUserAgentSettingsEfl& operator=(const HttpUserAgentSettingsEfl&) = delete;
+
// HttpUserAgentSettings implementation
std::string GetAcceptLanguage() const override;
std::string GetUserAgent() const override;
-
- private:
- // DISALLOW_COPY_AND_ASSIGN(HttpUserAgentSettingsEfl);
};
#endif // HTTP_USER_AGENT_SETTINGS_EFL_H_
PermissionControllerDelegateEfl();
~PermissionControllerDelegateEfl() override;
+ PermissionControllerDelegateEfl(const PermissionControllerDelegateEfl&) =
+ delete;
+ PermissionControllerDelegateEfl& operator=(
+ const PermissionControllerDelegateEfl&) = delete;
+
void RequestPermission(PermissionType permission,
RenderFrameHost* render_frame_host,
const GURL& requesting_origin,
PendingRequestsMap pending_requests_;
base::WeakPtrFactory<PermissionControllerDelegateEfl> weak_ptr_factory_;
-
- // DISALLOW_COPY_AND_ASSIGN(PermissionControllerDelegateEfl);
};
}
Ewk_Context(bool incognito);
Ewk_Context(const std::string& injectedBundlePath);
~Ewk_Context();
- friend class base::RefCounted<Ewk_Context>;
- // DISALLOW_COPY_AND_ASSIGN(Ewk_Context);
+ Ewk_Context(const Ewk_Context&) = delete;
+ Ewk_Context& operator=(const Ewk_Context&) = delete;
+
+ friend class base::RefCounted<Ewk_Context>;
};
explicit _Ewk_Hit_Test(const Hit_Test_Params& params);
~_Ewk_Hit_Test();
+ _Ewk_Hit_Test(const _Ewk_Hit_Test&) = delete;
+ _Ewk_Hit_Test& operator=(const _Ewk_Hit_Test&) = delete;
+
Ewk_Hit_Test_Result_Context GetResultContext() const;
const char* GetLinkUri() const;
explicit Hit_Test_Node_Data(const Hit_Test_Params::Node_Data& data);
~Hit_Test_Node_Data();
+ Hit_Test_Node_Data(const Hit_Test_Node_Data&) = delete;
+ Hit_Test_Node_Data& operator=(const Hit_Test_Node_Data&) = delete;
+
const std::string tagName; // tag name for hit element
const std::string nodeValue; // node value for hit element
- Eina_Hash* attributeHash; // attribute data for hit element
-
- private:
- // DISALLOW_COPY_AND_ASSIGN(Hit_Test_Node_Data);
+ Eina_Hash* attributeHash; // attribute data for hit element
} nodeData;
// when hit node is image we need to store image buffer and filename extension
public:
explicit Hit_Test_Image_Buffer(const Hit_Test_Params::Image_Data& data);
- const std::string fileNameExtension; // image filename extension for hit element
- SkBitmap imageBitmap; // image pixels data
+ Hit_Test_Image_Buffer(const Hit_Test_Image_Buffer&) = delete;
+ Hit_Test_Image_Buffer& operator=(const Hit_Test_Image_Buffer&) = delete;
- private:
- // DISALLOW_COPY_AND_ASSIGN(Hit_Test_Image_Buffer);
+ const std::string fileNameExtension; // image filename extension for hit element
+ SkBitmap imageBitmap; // image pixels data
} imageData;
-
- // DISALLOW_COPY_AND_ASSIGN(_Ewk_Hit_Test);
};
const GURL& securityOrigin);
~Ewk_Notification();
+ Ewk_Notification(const Ewk_Notification&) = delete;
+ Ewk_Notification& operator=(const Ewk_Notification&) = delete;
+
const char* GetBody() const;
const char* GetTitle() const;
bool IsSilent() const;
bool silent_;
uint64_t notificationID_;
std::unique_ptr<_Ewk_Security_Origin> origin_;
-
- // DISALLOW_COPY_AND_ASSIGN(Ewk_Notification);
};
struct Ewk_Notification_Permission_Request {
const GURL& source_origin);
~Ewk_Notification_Permission_Request() {}
+ Ewk_Notification_Permission_Request(
+ const Ewk_Notification_Permission_Request&) = delete;
+ Ewk_Notification_Permission_Request& operator=(
+ const Ewk_Notification_Permission_Request&) = delete;
+
const _Ewk_Security_Origin* GetSecurityOrigin() const;
bool IsDecided() const;
bool IsSuspended() const;
base::OnceCallback<void(blink::mojom::PermissionStatus)> callback_;
bool decided_;
mutable bool suspended_;
-
- // DISALLOW_COPY_AND_ASSIGN(Ewk_Notification_Permission_Request);
};
public:
_Ewk_Quota_Permission_Request(const GURL& url, int64_t newQuota, bool isPersistent);
+ _Ewk_Quota_Permission_Request(const _Ewk_Quota_Permission_Request&) = delete;
+ _Ewk_Quota_Permission_Request& operator=(
+ const _Ewk_Quota_Permission_Request) = delete;
+
void setView(Evas_Object* view);
Evas_Object* getView() const;
Eina_Stringshare* GetHost() const;
int64_t newQuota_;
bool isPersistent_;
Evas_Object* view_;
-
- // DISALLOW_COPY_AND_ASSIGN(_Ewk_Quota_Permission_Request);
};
#endif // EWK_QUOTA_PERMISSION_REQUEST_PRIVATE_H
_Ewk_Security_Origin(const GURL& url);
~_Ewk_Security_Origin();
+ _Ewk_Security_Origin(const _Ewk_Security_Origin&) = delete;
+ _Ewk_Security_Origin& operator=(const _Ewk_Security_Origin&) = delete;
+
GURL GetURL() const;
Eina_Stringshare* GetHost() const;
Eina_Stringshare* GetProtocol() const;
const Eina_Stringshare* host_;
const Eina_Stringshare* protocol_;
const int port_;
-
- // DISALLOW_COPY_AND_ASSIGN(_Ewk_Security_Origin);
};
#endif // ewk_security_origin_private_h
struct EwkViewImpl {
explicit EwkViewImpl(EWebView* wv) : wv_(wv) {}
~EwkViewImpl() { delete(wv_); }
+
+ EwkViewImpl(const EwkViewImpl&) = delete;
+ EwkViewImpl& operator=(const EwkViewImpl&) = delete;
+
EWebView* GetTizenWebView() { return wv_; }
const EWebView* GetTizenWebView() const { return wv_; }
private:
EWebView* wv_;
- // DISALLOW_COPY_AND_ASSIGN(EwkViewImpl);
};
Evas_Smart_Class parent_smart_class_ = EVAS_SMART_CLASS_INIT_NULL;
void RequestHandleOrientationUnlock(EWebView* wv) const;
private:
WebViewDelegateEwk() {}
- // DISALLOW_COPY_AND_ASSIGN(WebViewDelegateEwk);
+
+ WebViewDelegateEwk(const WebViewDelegateEwk&) = delete;
+ WebViewDelegateEwk& operator=(const WebViewDelegateEwk&) = delete;
};
explicit ContentSettingsClientEfl(RenderFrame* render_view);
~ContentSettingsClientEfl() override;
+ ContentSettingsClientEfl(const ContentSettingsClientEfl&) = delete;
+ ContentSettingsClientEfl& operator=(const ContentSettingsClientEfl&) = delete;
+
// content::RenderFrameObserver implementation.
void OnDestruct() override;
// blink::WebContentSettingsClient implementation.
void DidNotAllowScript() override;
-
- private:
- // DISALLOW_COPY_AND_ASSIGN(ContentSettingsClientEfl);
};
} // namespace content
const std::string& html_data);
~PluginPlaceholderEfl() override;
+ PluginPlaceholderEfl(const PluginPlaceholderEfl&) = delete;
+ PluginPlaceholderEfl& operator=(const PluginPlaceholderEfl&) = delete;
+
// WebViewPlugin::Delegate (via PluginPlaceholder) method
v8::Local<v8::Value> GetV8Handle(v8::Isolate*) override;
blink::WebPlugin* CreatePlugin() override;
-
- // DISALLOW_COPY_AND_ASSIGN(PluginPlaceholderEfl);
};
#endif // PLUGIN_PLACEHOLDER_EFL_H_
friend class base::RefCounted<SharedURLLoaderFactoryEfl>;
~SharedURLLoaderFactoryEfl() override = default;
+ SharedURLLoaderFactoryEfl(const SharedURLLoaderFactoryEfl&) = delete;
+ SharedURLLoaderFactoryEfl& operator=(const SharedURLLoaderFactoryEfl&) =
+ delete;
+
// NetworkContext using the network service, if the network service is
// enabled. mojo::NullRemote(), otherwise.
mojo::Remote<network::mojom::NetworkContext> network_service_network_context_;
mojo::Remote<network::mojom::URLLoaderFactory> url_loader_factory_;
-
- // DISALLOW_COPY_AND_ASSIGN(SharedURLLoaderFactoryEfl);
};
/* LCOV_EXCL_STOP */
protected:
virtual ~URLRequestContextGetterEfl();
+ URLRequestContextGetterEfl(const URLRequestContextGetterEfl&) = delete;
+ URLRequestContextGetterEfl& operator=(const URLRequestContextGetterEfl&) =
+ delete;
+
private:
void CreateSQLitePersistentCookieStore(
const base::FilePath& path,
std::unique_ptr<net::CertVerifier> cert_verifier_;
std::unique_ptr<net::URLRequestContext> url_request_context_;
base::WeakPtrFactory<URLRequestContextGetterEfl> weak_ptr_factory_;
-
- // DISALLOW_COPY_AND_ASSIGN(URLRequestContextGetterEfl);
};
}; // namespace content
WebContentsDelegateEfl(EWebView*);
~WebContentsDelegateEfl() override;
+ WebContentsDelegateEfl(const WebContentsDelegateEfl&) = delete;
+ WebContentsDelegateEfl& operator=(const WebContentsDelegateEfl&) = delete;
+
// WebContentsDelegate overrides.
WebContents* OpenURLFromTab(WebContents* source,
const OpenURLParams& params) override;
base::WeakPtrFactory<WebContentsDelegateEfl> weak_ptr_factory_;
std::unique_ptr<_Ewk_Certificate_Policy_Decision>
certificate_policy_decision_;
-
- // DISALLOW_COPY_AND_ASSIGN(WebContentsDelegateEfl);
};
}
public:
WebContentsEflDelegateEwk(EWebView*);
+ WebContentsEflDelegateEwk(const WebContentsEflDelegateEwk&) = delete;
+ WebContentsEflDelegateEwk& operator=(const WebContentsEflDelegateEwk&) =
+ delete;
+
bool WebContentsCreateAsync(WebContentsCreateCallback) override;
void SetUpSmartObject(void*platform_data, void* native_view) override;
private:
EWebView* web_view_;
-
- // DISALLOW_COPY_AND_ASSIGN(WebContentsEflDelegateEwk);
};
#endif // CONTENT_PUBLIC_BROWSER_WEB_CONTENTS_EFL_DELEGATE_EWK_H_
private:
WrtDynamicPlugin();
+ WrtDynamicPlugin(const WrtDynamicPlugin&) = delete;
+ WrtDynamicPlugin& operator=(const WrtDynamicPlugin&) = delete;
+
ParseUrlFun parseURL_;
SetWidgetInfoFun set_widget_info_;
DatabaseAttachFun database_attach_;
OnIPCMessageFun on_IPC_message_;
-
- // DISALLOW_COPY_AND_ASSIGN(WrtDynamicPlugin);
};
#endif // EWK_EFL_INTEGRATION_WRT_WRT_DYNAMICPLUGIN_H_
: file_task_runner_(file_task_runner) {}
~WrtFileProtocolHandler() override {}
+ WrtFileProtocolHandler(const WrtFileProtocolHandler&) = delete;
+ WrtFileProtocolHandler& operator=(const WrtFileProtocolHandler&) = delete;
+
std::unique_ptr<URLRequestJob> CreateJob(URLRequest* request) const override;
bool IsSafeRedirectTarget(const GURL& location) const override {
return false;
bool GetWrtParsedUrl(const GURL& url, GURL& parsed_url) const;
const scoped_refptr<base::TaskRunner> file_task_runner_;
- // DISALLOW_COPY_AND_ASSIGN(WrtFileProtocolHandler);
};
} // namespace net
WrtWidgetHost();
+ WrtWidgetHost(const WrtWidgetHost&) = delete;
+ WrtWidgetHost& operator=(const WrtWidgetHost&) = delete;
+
void OnUrlRetrieved(int callback_id, const GURL& url);
scoped_refptr<WrtWidgetHostMessageFilter> message_filter_;
base::AtomicSequenceNumber callback_id_generator_;
callbacks_type callbacks_;
-
- // DISALLOW_COPY_AND_ASSIGN(WrtWidgetHost);
};
projects / platform / framework / web / chromium-efl.git / commitdiff