diff --git a/cef3/cef.gyp b/cef3/cef.gyp index 69b484456..4d9827425 100644 --- a/cef3/cef.gyp +++ b/cef3/cef.gyp @@ -244,6 +244,7 @@ 'tests/unittests/cookie_unittest.cc', 'tests/unittests/dialog_unittest.cc', 'tests/unittests/dom_unittest.cc', + 'tests/unittests/geolocation_unittest.cc', 'tests/unittests/jsdialog_unittest.cc', 'tests/unittests/navigation_unittest.cc', 'tests/unittests/process_message_unittest.cc', @@ -818,6 +819,7 @@ 'libcef/browser/download_manager_delegate.h', 'libcef/browser/frame_host_impl.cc', 'libcef/browser/frame_host_impl.h', + 'libcef/browser/geolocation_impl.cc', 'libcef/browser/internal_scheme_handler.cc', 'libcef/browser/internal_scheme_handler.h', 'libcef/browser/javascript_dialog.h', diff --git a/cef3/cef_paths.gypi b/cef3/cef_paths.gypi index 18a07d701..4756e4a8a 100644 --- a/cef3/cef_paths.gypi +++ b/cef3/cef_paths.gypi @@ -27,6 +27,7 @@ 'include/cef_download_item.h', 'include/cef_focus_handler.h', 'include/cef_frame.h', + 'include/cef_geolocation.h', 'include/cef_geolocation_handler.h', 'include/cef_jsdialog_handler.h', 'include/cef_keyboard_handler.h', @@ -73,6 +74,7 @@ 'include/capi/cef_download_item_capi.h', 'include/capi/cef_focus_handler_capi.h', 'include/capi/cef_frame_capi.h', + 'include/capi/cef_geolocation_capi.h', 'include/capi/cef_geolocation_handler_capi.h', 'include/capi/cef_jsdialog_handler_capi.h', 'include/capi/cef_keyboard_handler_capi.h', @@ -164,6 +166,8 @@ 'libcef_dll/cpptoc/geolocation_callback_cpptoc.h', 'libcef_dll/ctocpp/geolocation_handler_ctocpp.cc', 'libcef_dll/ctocpp/geolocation_handler_ctocpp.h', + 'libcef_dll/ctocpp/get_geolocation_callback_ctocpp.cc', + 'libcef_dll/ctocpp/get_geolocation_callback_ctocpp.h', 'libcef_dll/cpptoc/jsdialog_callback_cpptoc.cc', 'libcef_dll/cpptoc/jsdialog_callback_cpptoc.h', 'libcef_dll/ctocpp/jsdialog_handler_ctocpp.cc', @@ -310,6 +314,8 @@ 'libcef_dll/ctocpp/geolocation_callback_ctocpp.h', 'libcef_dll/cpptoc/geolocation_handler_cpptoc.cc', 'libcef_dll/cpptoc/geolocation_handler_cpptoc.h', + 'libcef_dll/cpptoc/get_geolocation_callback_cpptoc.cc', + 'libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h', 'libcef_dll/ctocpp/jsdialog_callback_ctocpp.cc', 'libcef_dll/ctocpp/jsdialog_callback_ctocpp.h', 'libcef_dll/cpptoc/jsdialog_handler_cpptoc.cc', diff --git a/cef3/include/capi/cef_geolocation_capi.h b/cef3/include/capi/cef_geolocation_capi.h new file mode 100644 index 000000000..c74b0609a --- /dev/null +++ b/cef3/include/capi/cef_geolocation_capi.h @@ -0,0 +1,80 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool and should not edited +// by hand. See the translator.README.txt file in the tools directory for +// more information. +// + +#ifndef CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_ +#define CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_ +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + +#include "include/capi/cef_base_capi.h" + + +/// +// Request a one-time geolocation update. This function bypasses any user +// permission checks so should only be used by code that is allowed to access +// location information. +/// +CEF_EXPORT int cef_get_geolocation( + struct _cef_get_geolocation_callback_t* callback); + +/// +// Implement this structure to receive geolocation updates. The functions of +// this structure will be called on the browser process UI thread. +/// +typedef struct _cef_get_geolocation_callback_t { + /// + // Base structure. + /// + cef_base_t base; + + /// + // Called with the 'best available' location information or, if the location + // update failed, with error information. + /// + void (CEF_CALLBACK *on_location_update)( + struct _cef_get_geolocation_callback_t* self, + const struct _cef_geoposition_t* position); +} cef_get_geolocation_callback_t; + + +#ifdef __cplusplus +} +#endif + +#endif // CEF_INCLUDE_CAPI_CEF_GEOLOCATION_CAPI_H_ diff --git a/cef3/include/cef_geolocation.h b/cef3/include/cef_geolocation.h new file mode 100644 index 000000000..69c08779c --- /dev/null +++ b/cef3/include/cef_geolocation.h @@ -0,0 +1,66 @@ +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the name Chromium Embedded +// Framework nor the names of its contributors may be used to endorse +// or promote products derived from this software without specific prior +// written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// --------------------------------------------------------------------------- +// +// The contents of this file must follow a specific format in order to +// support the CEF translator tool. See the translator.README.txt file in the +// tools directory for more information. +// + +#ifndef CEF_INCLUDE_CEF_GEOLOCATION_H_ +#define CEF_INCLUDE_CEF_GEOLOCATION_H_ +#pragma once + +#include "include/cef_base.h" + +/// +// Implement this interface to receive geolocation updates. The methods of this +// class will be called on the browser process UI thread. +/// +/*--cef(source=client)--*/ +class CefGetGeolocationCallback : public virtual CefBase { + public: + /// + // Called with the 'best available' location information or, if the location + // update failed, with error information. + /// + /*--cef()--*/ + virtual void OnLocationUpdate(const CefGeoposition& position) =0; +}; + +/// +// Request a one-time geolocation update. This function bypasses any user +// permission checks so should only be used by code that is allowed to access +// location information. +/// +/*--cef()--*/ +bool CefGetGeolocation(CefRefPtr callback); + +#endif // CEF_INCLUDE_CEF_GEOLOCATION_H_ diff --git a/cef3/include/internal/cef_types.h b/cef3/include/internal/cef_types.h index de2e09469..76665edda 100644 --- a/cef3/include/internal/cef_types.h +++ b/cef3/include/internal/cef_types.h @@ -1328,6 +1328,74 @@ enum cef_file_dialog_mode_t { FILE_DIALOG_SAVE, }; +/// +// Geoposition error codes. +/// +enum cef_geoposition_error_code_t { + GEOPOSITON_ERROR_NONE = 0, + GEOPOSITON_ERROR_PERMISSION_DENIED, + GEOPOSITON_ERROR_POSITION_UNAVAILABLE, + GEOPOSITON_ERROR_TIMEOUT, +}; + +/// +// Structure representing geoposition information. The properties of this +// structure correspond to those of the JavaScript Position object although +// their types may differ. +/// +typedef struct _cef_geoposition_t { + /// + // Latitude in decimal degrees north (WGS84 coordinate frame). + /// + double latitude; + + /// + // Longitude in decimal degrees west (WGS84 coordinate frame). + /// + double longitude; + + /// + // Altitude in meters (above WGS84 datum). + /// + double altitude; + + /// + // Accuracy of horizontal position in meters. + /// + double accuracy; + + /// + // Accuracy of altitude in meters. + /// + double altitude_accuracy; + + /// + // Heading in decimal degrees clockwise from true north. + /// + double heading; + + /// + // Horizontal component of device velocity in meters per second. + /// + double speed; + + /// + // Time of position measurement in miliseconds since Epoch in UTC time. This + // is taken from the host computer's system clock. + /// + cef_time_t timestamp; + + /// + // Error code, see enum above. + /// + cef_geoposition_error_code_t error_code; + + /// + // Human-readable error message. + /// + cef_string_t error_message; +} cef_geoposition_t; + #ifdef __cplusplus } #endif diff --git a/cef3/include/internal/cef_types_wrappers.h b/cef3/include/internal/cef_types_wrappers.h index 2fea2173e..4b6a3d876 100644 --- a/cef3/include/internal/cef_types_wrappers.h +++ b/cef3/include/internal/cef_types_wrappers.h @@ -1,4 +1,4 @@ -// Copyright (c) 2011 Marshall A. Greenblatt. All rights reserved. +// Copyright (c) 2012 Marshall A. Greenblatt. All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are @@ -589,4 +589,34 @@ class CefProxyInfo : public CefStructBase { CefString ProxyList() const { return CefString(&proxyList); } }; +struct CefGeopositionTraits { + typedef cef_geoposition_t struct_type; + + static inline void init(struct_type* s) {} + + static inline void clear(struct_type* s) { + cef_string_clear(&s->error_message); + } + + static inline void set(const struct_type* src, struct_type* target, + bool copy) { + target->latitude = src->latitude; + target->longitude = src->longitude; + target->altitude = src->altitude; + target->accuracy = src->accuracy; + target->altitude_accuracy = src->altitude_accuracy; + target->heading = src->heading; + target->speed = src->speed; + target->timestamp = src->timestamp; + target->error_code = src->error_code; + cef_string_set(src->error_message.str, src->error_message.length, + &target->error_message, copy); + } +}; + +/// +// Class representing a geoposition. +/// +typedef CefStructBase CefGeoposition; + #endif // CEF_INCLUDE_INTERNAL_CEF_TYPES_WRAPPERS_H_ diff --git a/cef3/libcef/browser/geolocation_impl.cc b/cef3/libcef/browser/geolocation_impl.cc new file mode 100644 index 000000000..3c7746e36 --- /dev/null +++ b/cef3/libcef/browser/geolocation_impl.cc @@ -0,0 +1,79 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that can +// be found in the LICENSE file. + +#include "include/cef_geolocation.h" +#include "libcef/browser/context.h" +#include "libcef/browser/thread_util.h" +#include "libcef/common/time_util.h" +#include "base/logging.h" +#include "content/browser/geolocation/geolocation_provider.h" +#include "content/public/common/geoposition.h" + +namespace { + +void SetPosition(const content::Geoposition& source, CefGeoposition& target) { + target.latitude = source.latitude; + target.longitude = source.longitude; + target.altitude = source.altitude; + target.accuracy = source.accuracy; + target.altitude_accuracy = source.altitude_accuracy; + target.heading = source.heading; + target.speed = source.speed; + cef_time_from_basetime(source.timestamp, target.timestamp); + + switch (source.error_code) { + case content::Geoposition::ERROR_CODE_NONE: + target.error_code = GEOPOSITON_ERROR_NONE; + break; + case content::Geoposition::ERROR_CODE_PERMISSION_DENIED: + target.error_code = GEOPOSITON_ERROR_PERMISSION_DENIED; + break; + case content::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE: + target.error_code = GEOPOSITON_ERROR_POSITION_UNAVAILABLE; + break; + case content::Geoposition::ERROR_CODE_TIMEOUT: + target.error_code = GEOPOSITON_ERROR_TIMEOUT; + break; + } + + CefString(&target.error_message) = source.error_message; +} + +void LocationCallback(CefRefPtr callback, + const content::Geoposition& position) { + if (CEF_CURRENTLY_ON_UIT()) { + CefGeoposition cef_position; + SetPosition(position, cef_position); + callback->OnLocationUpdate(cef_position); + } else { + CEF_POST_TASK(CEF_UIT, base::Bind(LocationCallback, callback, position)); + } +} + +} // namespace + +bool CefGetGeolocation(CefRefPtr callback) { + if (!CONTEXT_STATE_VALID()) { + NOTREACHED() << "context not valid"; + return false; + } + + if (!callback.get()) { + NOTREACHED() << "invalid parameter"; + return false; + } + + if (CEF_CURRENTLY_ON_IOT()) { + GeolocationProvider* provider = GeolocationProvider::GetInstance(); + if (provider) { + provider->RequestCallback(base::Bind(LocationCallback, callback)); + return true; + } + return false; + } else { + CEF_POST_TASK(CEF_IOT, + base::Bind(base::IgnoreResult(CefGetGeolocation), callback)); + return true; + } +} diff --git a/cef3/libcef_dll/cpptoc/get_geolocation_callback_cpptoc.cc b/cef3/libcef_dll/cpptoc/get_geolocation_callback_cpptoc.cc new file mode 100644 index 000000000..5956d241d --- /dev/null +++ b/cef3/libcef_dll/cpptoc/get_geolocation_callback_cpptoc.cc @@ -0,0 +1,57 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h" + + +// MEMBER FUNCTIONS - Body may be edited by hand. + +void CEF_CALLBACK get_geolocation_callback_on_location_update( + struct _cef_get_geolocation_callback_t* self, + const struct _cef_geoposition_t* position) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + DCHECK(self); + if (!self) + return; + // Verify param: position; type: struct_byref_const + DCHECK(position); + if (!position) + return; + + // Translate param: position; type: struct_byref_const + CefGeoposition positionObj; + if (position) + positionObj.Set(*position, false); + + // Execute + CefGetGeolocationCallbackCppToC::Get(self)->OnLocationUpdate( + positionObj); +} + + +// CONSTRUCTOR - Do not edit by hand. + +CefGetGeolocationCallbackCppToC::CefGetGeolocationCallbackCppToC( + CefGetGeolocationCallback* cls) + : CefCppToC(cls) { + struct_.struct_.on_location_update = + get_geolocation_callback_on_location_update; +} + +#ifndef NDEBUG +template<> long CefCppToC::DebugObjCt = + 0; +#endif + diff --git a/cef3/libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h b/cef3/libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h new file mode 100644 index 000000000..b459711b1 --- /dev/null +++ b/cef3/libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h @@ -0,0 +1,37 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CPPTOC_GET_GEOLOCATION_CALLBACK_CPPTOC_H_ +#define CEF_LIBCEF_DLL_CPPTOC_GET_GEOLOCATION_CALLBACK_CPPTOC_H_ +#pragma once + +#ifndef USING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed wrapper-side only") +#else // USING_CEF_SHARED + +#include "include/cef_geolocation.h" +#include "include/capi/cef_geolocation_capi.h" +#include "libcef_dll/cpptoc/cpptoc.h" + +// Wrap a C++ class with a C structure. +// This class may be instantiated and accessed wrapper-side only. +class CefGetGeolocationCallbackCppToC + : public CefCppToC { + public: + explicit CefGetGeolocationCallbackCppToC(CefGetGeolocationCallback* cls); + virtual ~CefGetGeolocationCallbackCppToC() {} +}; + +#endif // USING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CPPTOC_GET_GEOLOCATION_CALLBACK_CPPTOC_H_ + diff --git a/cef3/libcef_dll/ctocpp/get_geolocation_callback_ctocpp.cc b/cef3/libcef_dll/ctocpp/get_geolocation_callback_ctocpp.cc new file mode 100644 index 000000000..4d5493be1 --- /dev/null +++ b/cef3/libcef_dll/ctocpp/get_geolocation_callback_ctocpp.cc @@ -0,0 +1,36 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#include "libcef_dll/ctocpp/get_geolocation_callback_ctocpp.h" + + +// VIRTUAL METHODS - Body may be edited by hand. + +void CefGetGeolocationCallbackCToCpp::OnLocationUpdate( + const CefGeoposition& position) { + if (CEF_MEMBER_MISSING(struct_, on_location_update)) + return; + + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Execute + struct_->on_location_update(struct_, + &position); +} + + +#ifndef NDEBUG +template<> long CefCToCpp::DebugObjCt = + 0; +#endif + diff --git a/cef3/libcef_dll/ctocpp/get_geolocation_callback_ctocpp.h b/cef3/libcef_dll/ctocpp/get_geolocation_callback_ctocpp.h new file mode 100644 index 000000000..e3f3af001 --- /dev/null +++ b/cef3/libcef_dll/ctocpp/get_geolocation_callback_ctocpp.h @@ -0,0 +1,42 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. +// +// --------------------------------------------------------------------------- +// +// This file was generated by the CEF translator tool. If making changes by +// hand only do so within the body of existing method and function +// implementations. See the translator.README.txt file in the tools directory +// for more information. +// + +#ifndef CEF_LIBCEF_DLL_CTOCPP_GET_GEOLOCATION_CALLBACK_CTOCPP_H_ +#define CEF_LIBCEF_DLL_CTOCPP_GET_GEOLOCATION_CALLBACK_CTOCPP_H_ +#pragma once + +#ifndef BUILDING_CEF_SHARED +#pragma message("Warning: "__FILE__" may be accessed DLL-side only") +#else // BUILDING_CEF_SHARED + +#include "include/cef_geolocation.h" +#include "include/capi/cef_geolocation_capi.h" +#include "libcef_dll/ctocpp/ctocpp.h" + +// Wrap a C structure with a C++ class. +// This class may be instantiated and accessed DLL-side only. +class CefGetGeolocationCallbackCToCpp + : public CefCToCpp { + public: + explicit CefGetGeolocationCallbackCToCpp(cef_get_geolocation_callback_t* str) + : CefCToCpp(str) {} + virtual ~CefGetGeolocationCallbackCToCpp() {} + + // CefGetGeolocationCallback methods + virtual void OnLocationUpdate(const CefGeoposition& position) OVERRIDE; +}; + +#endif // BUILDING_CEF_SHARED +#endif // CEF_LIBCEF_DLL_CTOCPP_GET_GEOLOCATION_CALLBACK_CTOCPP_H_ + diff --git a/cef3/libcef_dll/libcef_dll.cc b/cef3/libcef_dll/libcef_dll.cc index e9d737b6f..eabb66600 100644 --- a/cef3/libcef_dll/libcef_dll.cc +++ b/cef3/libcef_dll/libcef_dll.cc @@ -12,6 +12,8 @@ #include "include/cef_app.h" #include "include/capi/cef_app_capi.h" +#include "include/cef_geolocation.h" +#include "include/capi/cef_geolocation_capi.h" #include "include/cef_origin_whitelist.h" #include "include/capi/cef_origin_whitelist_capi.h" #include "include/cef_path_util.h" @@ -76,6 +78,7 @@ #include "libcef_dll/ctocpp/download_handler_ctocpp.h" #include "libcef_dll/ctocpp/focus_handler_ctocpp.h" #include "libcef_dll/ctocpp/geolocation_handler_ctocpp.h" +#include "libcef_dll/ctocpp/get_geolocation_callback_ctocpp.h" #include "libcef_dll/ctocpp/jsdialog_handler_ctocpp.h" #include "libcef_dll/ctocpp/keyboard_handler_ctocpp.h" #include "libcef_dll/ctocpp/life_span_handler_ctocpp.h" @@ -193,6 +196,7 @@ CEF_EXPORT void cef_shutdown() { DCHECK_EQ(CefFrameCppToC::DebugObjCt, 0); DCHECK_EQ(CefGeolocationCallbackCppToC::DebugObjCt, 0); DCHECK_EQ(CefGeolocationHandlerCToCpp::DebugObjCt, 0); + DCHECK_EQ(CefGetGeolocationCallbackCToCpp::DebugObjCt, 0); DCHECK_EQ(CefJSDialogCallbackCppToC::DebugObjCt, 0); DCHECK_EQ(CefJSDialogHandlerCToCpp::DebugObjCt, 0); DCHECK_EQ(CefKeyboardHandlerCToCpp::DebugObjCt, 0); @@ -255,6 +259,23 @@ CEF_EXPORT void cef_quit_message_loop() { CefQuitMessageLoop(); } +CEF_EXPORT int cef_get_geolocation( + struct _cef_get_geolocation_callback_t* callback) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: callback; type: refptr_diff + DCHECK(callback); + if (!callback) + return 0; + + // Execute + bool _retval = CefGetGeolocation( + CefGetGeolocationCallbackCToCpp::Wrap(callback)); + + // Return type: bool + return _retval; +} + CEF_EXPORT int cef_add_cross_origin_whitelist_entry( const cef_string_t* source_origin, const cef_string_t* target_protocol, const cef_string_t* target_domain, int allow_target_subdomains) { diff --git a/cef3/libcef_dll/wrapper/libcef_dll_wrapper.cc b/cef3/libcef_dll/wrapper/libcef_dll_wrapper.cc index 2aae37853..2531d3ca8 100644 --- a/cef3/libcef_dll/wrapper/libcef_dll_wrapper.cc +++ b/cef3/libcef_dll/wrapper/libcef_dll_wrapper.cc @@ -12,6 +12,8 @@ #include "include/cef_app.h" #include "include/capi/cef_app_capi.h" +#include "include/cef_geolocation.h" +#include "include/capi/cef_geolocation_capi.h" #include "include/cef_origin_whitelist.h" #include "include/capi/cef_origin_whitelist_capi.h" #include "include/cef_path_util.h" @@ -42,6 +44,7 @@ #include "libcef_dll/cpptoc/download_handler_cpptoc.h" #include "libcef_dll/cpptoc/focus_handler_cpptoc.h" #include "libcef_dll/cpptoc/geolocation_handler_cpptoc.h" +#include "libcef_dll/cpptoc/get_geolocation_callback_cpptoc.h" #include "libcef_dll/cpptoc/jsdialog_handler_cpptoc.h" #include "libcef_dll/cpptoc/keyboard_handler_cpptoc.h" #include "libcef_dll/cpptoc/life_span_handler_cpptoc.h" @@ -185,6 +188,7 @@ CEF_GLOBAL void CefShutdown() { DCHECK_EQ(CefFrameCToCpp::DebugObjCt, 0); DCHECK_EQ(CefGeolocationCallbackCToCpp::DebugObjCt, 0); DCHECK_EQ(CefGeolocationHandlerCppToC::DebugObjCt, 0); + DCHECK_EQ(CefGetGeolocationCallbackCppToC::DebugObjCt, 0); DCHECK_EQ(CefJSDialogCallbackCToCpp::DebugObjCt, 0); DCHECK_EQ(CefJSDialogHandlerCppToC::DebugObjCt, 0); DCHECK_EQ(CefKeyboardHandlerCppToC::DebugObjCt, 0); @@ -247,6 +251,23 @@ CEF_GLOBAL void CefQuitMessageLoop() { cef_quit_message_loop(); } +CEF_GLOBAL bool CefGetGeolocation( + CefRefPtr callback) { + // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING + + // Verify param: callback; type: refptr_diff + DCHECK(callback.get()); + if (!callback.get()) + return false; + + // Execute + int _retval = cef_get_geolocation( + CefGetGeolocationCallbackCppToC::Wrap(callback)); + + // Return type: bool + return _retval?true:false; +} + CEF_GLOBAL bool CefAddCrossOriginWhitelistEntry(const CefString& source_origin, const CefString& target_protocol, const CefString& target_domain, bool allow_target_subdomains) { diff --git a/cef3/tests/unittests/geolocation_unittest.cc b/cef3/tests/unittests/geolocation_unittest.cc new file mode 100644 index 000000000..edfc02043 --- /dev/null +++ b/cef3/tests/unittests/geolocation_unittest.cc @@ -0,0 +1,204 @@ +// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights +// reserved. Use of this source code is governed by a BSD-style license that +// can be found in the LICENSE file. + +#include "include/cef_geolocation.h" +#include "include/cef_runnable.h" +#include "tests/unittests/test_handler.h" +#include "tests/unittests/test_util.h" +#include "base/synchronization/waitable_event.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace { + +const char* kTestOrigin = "http://tests/"; +const char* kTestUrl = "http://tests/GeolocationTestHandler"; +const char* kTestAllowUrl = "http://tests/GeolocationTestHandler.Allow"; +const char* kTestDenyUrl = "http://tests/GeolocationTestHandler.Deny"; +const char* kTestCancelUrl = "http://tests/GeolocationTestHandler.Cancel"; + +enum TestMode { + TEST_ALLOW, + TEST_DENY, + TEST_CANCEL, +}; + +class GeolocationTestHandler : public TestHandler { + public: + GeolocationTestHandler(const TestMode& mode, bool async) + : mode_(mode), + async_(async), + request_id_(-1) { + } + + virtual void RunTest() OVERRIDE { + std::string html = + "TEST START"; + AddResource(kTestUrl, html, "text/html"); + + std::string end_html = "TEST END"; + AddResource(kTestAllowUrl, end_html, "text/html"); + AddResource(kTestDenyUrl, end_html, "text/html"); + AddResource(kTestCancelUrl, end_html, "text/html"); + + // Create the browser + CreateBrowser(kTestUrl); + } + + virtual void OnLoadEnd(CefRefPtr browser, + CefRefPtr frame, + int httpStatusCode) OVERRIDE { + std::string url = frame->GetURL(); + if (url != kTestUrl) { + if (url == kTestAllowUrl) + got_allow_.yes(); + else if (url == kTestDenyUrl) + got_deny_.yes(); + else if (url == kTestCancelUrl) + got_cancel_.yes(); + + DestroyTest(); + } + } + + void ExecuteCallback(CefRefPtr callback) { + if (mode_ == TEST_ALLOW) + callback->Continue(true); + else if (mode_ == TEST_DENY) + callback->Continue(false); + } + + virtual void OnRequestGeolocationPermission( + CefRefPtr browser, + const CefString& requesting_url, + int request_id, + CefRefPtr callback) OVERRIDE { + got_requestgeolocationpermission_.yes(); + + EXPECT_TRUE(CefCurrentlyOn(TID_IO)); + + EXPECT_STREQ(kTestOrigin, requesting_url.ToString().c_str()); + request_id_ = request_id; + + if (!async_) { + ExecuteCallback(callback); + } else { + CefPostTask(TID_UI, + NewCefRunnableMethod(this, &GeolocationTestHandler::ExecuteCallback, + callback)); + } + } + + virtual void OnCancelGeolocationPermission( + CefRefPtr browser, + const CefString& requesting_url, + int request_id) OVERRIDE { + got_cancelgeolocationpermission_.yes(); + + EXPECT_TRUE(CefCurrentlyOn(TID_IO)); + + EXPECT_STREQ(kTestOrigin, requesting_url.ToString().c_str()); + EXPECT_EQ(request_id, request_id_); + } + + virtual void DestroyTest() OVERRIDE { + EXPECT_TRUE(got_requestgeolocationpermission_); + if (mode_ == TEST_CANCEL) + EXPECT_TRUE(got_cancelgeolocationpermission_); + else + EXPECT_FALSE(got_cancelgeolocationpermission_); + + TestHandler::DestroyTest(); + } + + TestMode mode_; + bool async_; + + int request_id_; + + TrackCallback got_requestgeolocationpermission_; + TrackCallback got_cancelgeolocationpermission_; + TrackCallback got_allow_; + TrackCallback got_cancel_; + TrackCallback got_deny_; +}; + +} // namespace + +TEST(GeolocationTest, HandlerAllow) { + CefRefPtr handler = + new GeolocationTestHandler(TEST_ALLOW, false); + handler->ExecuteTest(); + EXPECT_TRUE(handler->got_allow_); +} + +TEST(GeolocationTest, HandlerAllowAsync) { + CefRefPtr handler = + new GeolocationTestHandler(TEST_ALLOW, true); + handler->ExecuteTest(); + EXPECT_TRUE(handler->got_allow_); +} + +TEST(GeolocationTest, HandlerDeny) { + CefRefPtr handler = + new GeolocationTestHandler(TEST_DENY, false); + handler->ExecuteTest(); + EXPECT_TRUE(handler->got_deny_); +} + +TEST(GeolocationTest, HandlerDenyAsync) { + CefRefPtr handler = + new GeolocationTestHandler(TEST_DENY, true); + handler->ExecuteTest(); + EXPECT_TRUE(handler->got_deny_); +} + +TEST(GeolocationTest, HandlerCancel) { + CefRefPtr handler = + new GeolocationTestHandler(TEST_CANCEL, false); + handler->ExecuteTest(); + EXPECT_TRUE(handler->got_cancel_); +} + + +namespace { + +class TestGetGeolocationCallback : public CefGetGeolocationCallback { + public: + explicit TestGetGeolocationCallback(base::WaitableEvent* event) + : event_(event) { + } + + virtual void OnLocationUpdate(const CefGeoposition& position) OVERRIDE { + EXPECT_TRUE(CefCurrentlyOn(TID_UI)); + EXPECT_EQ(position.error_code, GEOPOSITON_ERROR_NONE); + EXPECT_NE(position.latitude, 0.0); + EXPECT_NE(position.longitude, 0.0); + EXPECT_NE(position.accuracy, 0.0); + EXPECT_NE(position.timestamp.year, 0); + event_->Signal(); + } + +private: + base::WaitableEvent* event_; + + IMPLEMENT_REFCOUNTING(TestGetGeolocationCallback); +}; + +} // namespace + +TEST(GeolocationTest, GetGeolocation) { + base::WaitableEvent event(false, false); + CefGetGeolocation(new TestGetGeolocationCallback(&event)); + event.Wait(); +} diff --git a/cef3/tests/unittests/test_handler.h b/cef3/tests/unittests/test_handler.h index 4e5d74b04..eaa3332be 100644 --- a/cef3/tests/unittests/test_handler.h +++ b/cef3/tests/unittests/test_handler.h @@ -33,6 +33,7 @@ class TrackCallback { class TestHandler : public CefClient, public CefDialogHandler, public CefDisplayHandler, + public CefGeolocationHandler, public CefJSDialogHandler, public CefLifeSpanHandler, public CefLoadHandler, @@ -51,6 +52,9 @@ class TestHandler : public CefClient, virtual CefRefPtr GetDisplayHandler() OVERRIDE { return this; } + virtual CefRefPtr GetGeolocationHandler() OVERRIDE { + return this; + } virtual CefRefPtr GetJSDialogHandler() OVERRIDE { return this; }