cefpython/src/process_message_utils.pyx at master · linesight/cefpython · GitHub

History

388 lines (375 loc) · 17.4 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

# Project website: https://github.com/cztomczak/cefpython

# CefListValue->SetXxxx() functions need first param to be be cast

# to (int) because GetSize() returns size_t and generates a warning

# when compiling on VS2008 for x64 platform. Issue reported here:

# https://github.com/cztomczak/cefpython/issues/165

# Here in pyx you also need to convert Py_ssize_t returned by

# enumerate(), to an int.

include "cefpython.pyx"

include "utils.pyx"

from libc.stdint cimport int64_t, uint32_t

# -----------------------------------------------------------------------------

# CEF values to Python values

# -----------------------------------------------------------------------------

cdef object CheckForCefPythonMessageHash(CefRefPtr[CefBrowser] cefBrowser,

py_string pyString):

# A javascript callback from the Renderer process is sent as a string.

# TODO: this could be sent using CefBinaryNamedString in the future,

# see this topic "Sending custom data types using process messaging":

# http://www.magpcss.org/ceforum/viewtopic.php?f=6&t=10881

cdef py_string cefPythonMessageHash = "####cefpython####"

cdef JavascriptCallback jsCallback

cdef py_string jsonData

cdef object message

if pyString.startswith(cefPythonMessageHash):

jsonData = pyString[len(cefPythonMessageHash):]

message = json.loads(jsonData)

if message and type(message) == dict and ("what" in message) \

and message["what"] == "javascript-callback":

jsCallback = CreateJavascriptCallback(

message["callbackId"], cefBrowser,

message["frameId"], message["functionName"])

return jsCallback

return pyString

cdef object CefValueToPyValue(CefRefPtr[CefValue] cefValue):

assert cefValue.get().IsValid(), "cefValue is invalid"

cdef cef_types.cef_value_type_t valueType = cefValue.get().GetType()

cdef CefRefPtr[CefBinaryValue] binaryValue

cdef uint32_t uint32_value = 0

cdef int64_t int64_value = 0

if valueType == cef_types.VTYPE_NULL:

return None

elif valueType == cef_types.VTYPE_BOOL:

return bool(cefValue.get().GetBool())

elif valueType == cef_types.VTYPE_INT:

return cefValue.get().GetInt()

elif valueType == cef_types.VTYPE_DOUBLE:

return cefValue.get().GetDouble()

elif valueType == cef_types.VTYPE_STRING:

return CefToPyString(cefValue.get().GetString())

elif valueType == cef_types.VTYPE_DICTIONARY:

return CefDictionaryValueToPyDict(

<CefRefPtr[CefBrowser]>nullptr,

cefValue.get().GetDictionary(),

elif valueType == cef_types.VTYPE_LIST:

return CefListValueToPyList(

<CefRefPtr[CefBrowser]>nullptr,

cefValue.get().GetList(),

elif valueType == cef_types.VTYPE_BINARY:

binaryValue = cefValue.get().GetBinary()

if binaryValue.get().GetSize() == sizeof(uint32_value):

binaryValue.get().GetData(

&uint32_value, sizeof(uint32_value), 0)

return uint32_value

elif binaryValue.get().GetSize() == sizeof(int64_value):

binaryValue.get().GetData(

&int64_value, sizeof(int64_value), 0)

return int64_value

else:

NonCriticalError("Unknown binary value, size=%s" % \

binaryValue.get().GetSize())

return None

else:

raise Exception("Unknown CefValue type=%s" % valueType)

# TODO: Use CefListValue.GetValue to get CefValue and use CefValueToPyValue

# for dictionary and lists?

cdef list CefListValueToPyList(

CefRefPtr[CefBrowser] cefBrowser,

CefRefPtr[CefListValue] cefListValue,

int nestingLevel=0):

assert cefListValue.get().IsValid(), "cefListValue is invalid"

if nestingLevel > 8:

raise Exception("CefListValueToPyList(): max nesting level (8)"

" exceeded")

cdef size_t index

cdef size_t size = cefListValue.get().GetSize()

cdef cef_types.cef_value_type_t valueType

cdef list ret = []

cdef CefRefPtr[CefBinaryValue] binaryValue

cdef uint32_t uint32_value = 0

cdef int64_t int64_value = 0

cdef object originallyString

for index in range(0, size):

valueType = cefListValue.get().GetType(index)

if valueType == cef_types.VTYPE_NULL:

ret.append(None)

elif valueType == cef_types.VTYPE_BOOL:

ret.append(bool(cefListValue.get().GetBool(index)))

elif valueType == cef_types.VTYPE_INT:

ret.append(cefListValue.get().GetInt(index))

elif valueType == cef_types.VTYPE_DOUBLE:

ret.append(cefListValue.get().GetDouble(index))

elif valueType == cef_types.VTYPE_STRING:

originallyString = CefToPyString(

cefListValue.get().GetString(index))

if cefBrowser.get():

originallyString = CheckForCefPythonMessageHash(cefBrowser,

originallyString)

ret.append(originallyString)

elif valueType == cef_types.VTYPE_DICTIONARY:

ret.append(CefDictionaryValueToPyDict(

cefBrowser,

cefListValue.get().GetDictionary(index),

nestingLevel + 1))

elif valueType == cef_types.VTYPE_LIST:

ret.append(CefListValueToPyList(

cefBrowser,

cefListValue.get().GetList(index),

nestingLevel + 1))

elif valueType == cef_types.VTYPE_BINARY:

binaryValue = cefListValue.get().GetBinary(index)

if binaryValue.get().GetSize() == sizeof(uint32_value):

binaryValue.get().GetData(

&uint32_value, sizeof(uint32_value), 0)

ret.append(uint32_value)

elif binaryValue.get().GetSize() == sizeof(int64_value):

binaryValue.get().GetData(

&int64_value, sizeof(int64_value), 0)

ret.append(int64_value)

else:

NonCriticalError("Unknown binary value, size=%s" % \

binaryValue.get().GetSize())

ret.append(None)

else:

raise Exception("Unknown CefValue type=%s" % valueType)

return ret

cdef dict CefDictionaryValueToPyDict(

CefRefPtr[CefBrowser] cefBrowser,

CefRefPtr[CefDictionaryValue] cefDictionaryValue,

int nestingLevel=0):

assert cefDictionaryValue.get().IsValid(), "cefDictionaryValue is invalid"

if nestingLevel > 8:

raise Exception("CefDictionaryValueToPyDict(): max nesting level (8)"

" exceeded")

cdef cpp_vector[CefString] keyList

cefDictionaryValue.get().GetKeys(keyList)

cdef cef_types.cef_value_type_t valueType

cdef dict ret = {}

# noinspection PyUnresolvedReferences

cdef cpp_vector[CefString].iterator iterator = keyList.begin()

cdef CefString cefKey

cdef py_string pyKey

cdef CefRefPtr[CefBinaryValue] binaryValue

cdef uint32_t uint32_value = 0

cdef int64_t int64_value = 0

cdef object originallyString

while iterator != keyList.end():

# noinspection PyUnresolvedReferences

cefKey = deref(iterator)

pyKey = CefToPyString(cefKey)

# noinspection PyUnresolvedReferences

preinc(iterator)

valueType = cefDictionaryValue.get().GetType(cefKey)

if valueType == cef_types.VTYPE_NULL:

ret[pyKey] = None

elif valueType == cef_types.VTYPE_BOOL:

ret[pyKey] = bool(cefDictionaryValue.get().GetBool(cefKey))

elif valueType == cef_types.VTYPE_INT:

ret[pyKey] = cefDictionaryValue.get().GetInt(cefKey)

elif valueType == cef_types.VTYPE_DOUBLE:

ret[pyKey] = cefDictionaryValue.get().GetDouble(cefKey)

elif valueType == cef_types.VTYPE_STRING:

originallyString = CefToPyString(

cefDictionaryValue.get().GetString(cefKey))

if cefBrowser.get():

originallyString = CheckForCefPythonMessageHash(cefBrowser,

originallyString)

ret[pyKey] = originallyString

elif valueType == cef_types.VTYPE_DICTIONARY:

ret[pyKey] = CefDictionaryValueToPyDict(

cefBrowser,

cefDictionaryValue.get().GetDictionary(cefKey),

nestingLevel + 1)

elif valueType == cef_types.VTYPE_LIST:

ret[pyKey] = CefListValueToPyList(

cefBrowser,

cefDictionaryValue.get().GetList(cefKey),

nestingLevel + 1)

elif valueType == cef_types.VTYPE_BINARY:

binaryValue = cefDictionaryValue.get().GetBinary(cefKey)

if binaryValue.get().GetSize() == sizeof(uint32_value):

binaryValue.get().GetData(

&uint32_value, sizeof(uint32_value), 0)

ret[pyKey] = uint32_value

elif binaryValue.get().GetSize() == sizeof(int64_value):

binaryValue.get().GetData(

&int64_value, sizeof(int64_value), 0)

ret[pyKey] = int64_value

else:

NonCriticalError("Unknown binary value, size=%s" % \

binaryValue.get().GetSize())

ret[pyKey] = None

else:

raise Exception("Unknown CefValue type = %s" % valueType)

return ret

# -----------------------------------------------------------------------------

# Python values to CEF values

# -----------------------------------------------------------------------------

cdef CefRefPtr[CefListValue] PyListToCefListValue(

int browserId,

object frameId,

list pyList,

int nestingLevel=0) except *:

if nestingLevel > 8:

raise Exception("PyListToCefListValue(): max nesting level (8)"

" exceeded")

cdef type valueType

cdef CefRefPtr[CefListValue] ret = CefListValue_Create()

cdef CefRefPtr[CefBinaryValue] binaryValue

cdef size_t index

for index_size_t, value in enumerate(pyList):

index = int(index_size_t)

valueType = type(value)

if valueType == type(None):

ret.get().SetNull(index)

elif valueType == bool:

ret.get().SetBool(index, bool(value))

elif valueType in (int, long):

# Int32 range is -2147483648..2147483647, we've increased the

# minimum size by one as Cython was throwing a warning:

# "unary minus operator applied to unsigned type, result still

# unsigned".

if -2147483647 <= value <= 2147483647:

ret.get().SetInt(index, int(value))

else:

# Long values become strings.

ret.get().SetString(index, PyToCefStringValue(str(value)))

elif valueType == float:

ret.get().SetDouble(index, float(value))

elif valueType == bytes or valueType == str \

or (PY_MAJOR_VERSION < 3 and valueType == unicode):

# The unicode type is not defined in Python 3.

ret.get().SetString(index, PyToCefStringValue(str(value)))

elif valueType == dict:

ret.get().SetDictionary(index, PyDictToCefDictionaryValue(

browserId, frameId, value, nestingLevel + 1))

elif valueType == list or valueType == tuple:

if valueType == tuple:

value = list(value)

ret.get().SetList(index, PyListToCefListValue(

browserId, frameId, value, nestingLevel + 1))

elif IsFunctionOrMethod(valueType):

ret.get().SetBinary(index, PutPythonCallback(

browserId, frameId, value))

else:

# Raising an exception probably not a good idea, why

# terminate application when we can cast it to string,

# the data may contain some non-standard object that is

# probably redundant, but casting to string will do no harm.

# This will handle the "type" type.

ret.get().SetString(index, PyToCefStringValue(str(value)))

return ret

cdef void PyListToExistingCefListValue(

int browserId,

object frameId,

list pyList,

CefRefPtr[CefListValue] cefListValue,

int nestingLevel=0) except *:

# When sending process messages you must use an existing

# CefListValue, see browser.pyx > SendProcessMessage().

if nestingLevel > 8:

raise Exception("PyListToCefListValue(): max nesting level (8)"

" exceeded")

cdef type valueType

cdef CefRefPtr[CefListValue] newCefListValue

cdef size_t index

for index_size_t, value in enumerate(pyList):

index = int(index_size_t)

valueType = type(value)

if valueType == type(None):

cefListValue.get().SetNull(index)

elif valueType == bool:

cefListValue.get().SetBool(index, bool(value))

elif valueType in (int, long):

# Int32 range is -2147483648..2147483647, we've increased the

# minimum size by one as Cython was throwing a warning:

# "unary minus operator applied to unsigned type, result still

# unsigned".

if -2147483647 <= value <= 2147483647:

cefListValue.get().SetInt(index, int(value))

else:

# Long values become strings.

cefListValue.get().SetString(index, PyToCefStringValue(str(

value)))

elif valueType == float:

cefListValue.get().SetDouble(index, float(value))

elif valueType == bytes or valueType == str \

or (PY_MAJOR_VERSION < 3 and valueType == unicode):

# The unicode type is not defined in Python 3.

cefListValue.get().SetString(index, PyToCefStringValue(str(value)))

elif valueType == dict:

cefListValue.get().SetDictionary(index, PyDictToCefDictionaryValue(

browserId, frameId, value, nestingLevel + 1))

elif valueType == list or valueType == tuple:

if valueType == tuple:

value = list(value)

newCefListValue = CefListValue_Create()

PyListToExistingCefListValue(browserId, frameId, value,

newCefListValue, nestingLevel + 1)

cefListValue.get().SetList(index, newCefListValue)

elif IsFunctionOrMethod(valueType):

cefListValue.get().SetBinary(index, PutPythonCallback(

browserId, frameId, value))

else:

# Raising an exception probably not a good idea, why

# terminate application when we can cast it to string,

# the data may contain some non-standard object that is

# probably redundant, but casting to string will do no harm.

# This will handle the "type" type.

cefListValue.get().SetString(index, PyToCefStringValue(str(value)))

cdef CefRefPtr[CefDictionaryValue] PyDictToCefDictionaryValue(

int browserId,

object frameId,

dict pyDict,

int nestingLevel=0) except *:

if nestingLevel > 8:

raise Exception("PyDictToCefDictionaryValue(): max nesting level (8)"

" exceeded")

cdef type valueType

cdef CefRefPtr[CefDictionaryValue] ret = CefDictionaryValue_Create()

cdef CefString cefKey

cdef object value

for pyKey in pyDict:

value = pyDict[pyKey]

valueType = type(value)

PyToCefString(pyKey, cefKey)

if valueType == type(None):

ret.get().SetNull(cefKey)

elif valueType == bool:

ret.get().SetBool(cefKey, bool(value))

elif valueType == int or valueType == long: # In Py3 int and long types are the same type.

# Int32 range is -2147483648..2147483647

if INT_MIN <= value <= INT_MAX:

ret.get().SetInt(cefKey, int(value))

else:

# Long values become strings.

ret.get().SetString(cefKey, PyToCefStringValue(str(value)))

elif valueType == float:

ret.get().SetDouble(cefKey, float(value))

elif valueType == bytes or valueType == str \

or (PY_MAJOR_VERSION < 3 and valueType == unicode):

# The unicode type is not defined in Python 3.

ret.get().SetString(cefKey, PyToCefStringValue(str(value)))

elif valueType == dict:

ret.get().SetDictionary(cefKey, PyDictToCefDictionaryValue(

browserId, frameId, value, nestingLevel + 1))

elif valueType == list or valueType == tuple:

if valueType == tuple:

value = list(value)

ret.get().SetList(cefKey, PyListToCefListValue(

browserId, frameId, value, nestingLevel + 1))

elif IsFunctionOrMethod(valueType):

ret.get().SetBinary(cefKey, PutPythonCallback(

browserId, frameId, value))

else:

# Raising an exception probably not a good idea, why

# terminate application when we can cast it to string,

# the data may contain some non-standard object that is

# probably redundant, but casting to string will do no harm.

# This will handle the "type" type.

ret.get().SetString(cefKey, PyToCefStringValue(str(value)))

return ret

cefpython/src/process_message_utils.pyx at master · linesight/cefpython · GitHub

Expand file tree

Breadcrumbs

process_message_utils.pyx

Latest commit

History

Breadcrumbs

process_message_utils.pyx

File metadata and controls