OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" | 5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" |
6 | 6 |
7 #include <stdio.h> | 7 #include <stdio.h> |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 #include <cmath> | 10 #include <cmath> |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
44 #include "gpu/command_buffer/service/gl_utils.h" | 44 #include "gpu/command_buffer/service/gl_utils.h" |
45 #include "gpu/command_buffer/service/gles2_cmd_clear_framebuffer.h" | 45 #include "gpu/command_buffer/service/gles2_cmd_clear_framebuffer.h" |
46 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h" | 46 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h" |
47 #include "gpu/command_buffer/service/gles2_cmd_validation.h" | 47 #include "gpu/command_buffer/service/gles2_cmd_validation.h" |
48 #include "gpu/command_buffer/service/gpu_state_tracer.h" | 48 #include "gpu/command_buffer/service/gpu_state_tracer.h" |
49 #include "gpu/command_buffer/service/gpu_switches.h" | 49 #include "gpu/command_buffer/service/gpu_switches.h" |
50 #include "gpu/command_buffer/service/gpu_tracer.h" | 50 #include "gpu/command_buffer/service/gpu_tracer.h" |
51 #include "gpu/command_buffer/service/image_manager.h" | 51 #include "gpu/command_buffer/service/image_manager.h" |
52 #include "gpu/command_buffer/service/mailbox_manager.h" | 52 #include "gpu/command_buffer/service/mailbox_manager.h" |
53 #include "gpu/command_buffer/service/memory_tracking.h" | 53 #include "gpu/command_buffer/service/memory_tracking.h" |
| 54 #include "gpu/command_buffer/service/path_manager.h" |
54 #include "gpu/command_buffer/service/program_manager.h" | 55 #include "gpu/command_buffer/service/program_manager.h" |
55 #include "gpu/command_buffer/service/query_manager.h" | 56 #include "gpu/command_buffer/service/query_manager.h" |
56 #include "gpu/command_buffer/service/renderbuffer_manager.h" | 57 #include "gpu/command_buffer/service/renderbuffer_manager.h" |
57 #include "gpu/command_buffer/service/shader_manager.h" | 58 #include "gpu/command_buffer/service/shader_manager.h" |
58 #include "gpu/command_buffer/service/shader_translator.h" | 59 #include "gpu/command_buffer/service/shader_translator.h" |
59 #include "gpu/command_buffer/service/shader_translator_cache.h" | 60 #include "gpu/command_buffer/service/shader_translator_cache.h" |
60 #include "gpu/command_buffer/service/texture_manager.h" | 61 #include "gpu/command_buffer/service/texture_manager.h" |
61 #include "gpu/command_buffer/service/valuebuffer_manager.h" | 62 #include "gpu/command_buffer/service/valuebuffer_manager.h" |
62 #include "gpu/command_buffer/service/vertex_array_manager.h" | 63 #include "gpu/command_buffer/service/vertex_array_manager.h" |
63 #include "gpu/command_buffer/service/vertex_attrib_manager.h" | 64 #include "gpu/command_buffer/service/vertex_attrib_manager.h" |
(...skipping 718 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
782 bool GenFramebuffersHelper(GLsizei n, const GLuint* client_ids); | 783 bool GenFramebuffersHelper(GLsizei n, const GLuint* client_ids); |
783 void DeleteFramebuffersHelper(GLsizei n, const GLuint* client_ids); | 784 void DeleteFramebuffersHelper(GLsizei n, const GLuint* client_ids); |
784 bool GenRenderbuffersHelper(GLsizei n, const GLuint* client_ids); | 785 bool GenRenderbuffersHelper(GLsizei n, const GLuint* client_ids); |
785 void DeleteRenderbuffersHelper(GLsizei n, const GLuint* client_ids); | 786 void DeleteRenderbuffersHelper(GLsizei n, const GLuint* client_ids); |
786 bool GenValuebuffersCHROMIUMHelper(GLsizei n, const GLuint* client_ids); | 787 bool GenValuebuffersCHROMIUMHelper(GLsizei n, const GLuint* client_ids); |
787 void DeleteValuebuffersCHROMIUMHelper(GLsizei n, const GLuint* client_ids); | 788 void DeleteValuebuffersCHROMIUMHelper(GLsizei n, const GLuint* client_ids); |
788 bool GenQueriesEXTHelper(GLsizei n, const GLuint* client_ids); | 789 bool GenQueriesEXTHelper(GLsizei n, const GLuint* client_ids); |
789 void DeleteQueriesEXTHelper(GLsizei n, const GLuint* client_ids); | 790 void DeleteQueriesEXTHelper(GLsizei n, const GLuint* client_ids); |
790 bool GenVertexArraysOESHelper(GLsizei n, const GLuint* client_ids); | 791 bool GenVertexArraysOESHelper(GLsizei n, const GLuint* client_ids); |
791 void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* client_ids); | 792 void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* client_ids); |
| 793 bool GenPathsCHROMIUMHelper(GLuint first_client_id, GLsizei range); |
| 794 bool DeletePathsCHROMIUMHelper(GLuint first_client_id, GLsizei range); |
792 | 795 |
793 // Helper for async upload token completion notification callback. | 796 // Helper for async upload token completion notification callback. |
794 base::Closure AsyncUploadTokenCompletionClosure(uint32 async_upload_token, | 797 base::Closure AsyncUploadTokenCompletionClosure(uint32 async_upload_token, |
795 uint32 sync_data_shm_id, | 798 uint32 sync_data_shm_id, |
796 uint32 sync_data_shm_offset); | 799 uint32 sync_data_shm_offset); |
797 | 800 |
798 | 801 |
799 | 802 |
800 // Workarounds | 803 // Workarounds |
801 void OnFboChanged() const; | 804 void OnFboChanged() const; |
(...skipping 12 matching lines...) Expand all Loading... |
814 } | 817 } |
815 | 818 |
816 FramebufferManager* framebuffer_manager() { | 819 FramebufferManager* framebuffer_manager() { |
817 return group_->framebuffer_manager(); | 820 return group_->framebuffer_manager(); |
818 } | 821 } |
819 | 822 |
820 ValuebufferManager* valuebuffer_manager() { | 823 ValuebufferManager* valuebuffer_manager() { |
821 return group_->valuebuffer_manager(); | 824 return group_->valuebuffer_manager(); |
822 } | 825 } |
823 | 826 |
| 827 PathManager* path_manager() { return group_->path_manager(); } |
| 828 |
824 ProgramManager* program_manager() { | 829 ProgramManager* program_manager() { |
825 return group_->program_manager(); | 830 return group_->program_manager(); |
826 } | 831 } |
827 | 832 |
828 ShaderManager* shader_manager() { | 833 ShaderManager* shader_manager() { |
829 return group_->shader_manager(); | 834 return group_->shader_manager(); |
830 } | 835 } |
831 | 836 |
832 ShaderTranslatorCache* shader_translator_cache() { | 837 ShaderTranslatorCache* shader_translator_cache() { |
833 return group_->shader_translator_cache(); | 838 return group_->shader_translator_cache(); |
(...skipping 710 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1544 | 1549 |
1545 // Wrappers for glIsXXX functions. | 1550 // Wrappers for glIsXXX functions. |
1546 bool DoIsEnabled(GLenum cap); | 1551 bool DoIsEnabled(GLenum cap); |
1547 bool DoIsBuffer(GLuint client_id); | 1552 bool DoIsBuffer(GLuint client_id); |
1548 bool DoIsFramebuffer(GLuint client_id); | 1553 bool DoIsFramebuffer(GLuint client_id); |
1549 bool DoIsProgram(GLuint client_id); | 1554 bool DoIsProgram(GLuint client_id); |
1550 bool DoIsRenderbuffer(GLuint client_id); | 1555 bool DoIsRenderbuffer(GLuint client_id); |
1551 bool DoIsShader(GLuint client_id); | 1556 bool DoIsShader(GLuint client_id); |
1552 bool DoIsTexture(GLuint client_id); | 1557 bool DoIsTexture(GLuint client_id); |
1553 bool DoIsVertexArrayOES(GLuint client_id); | 1558 bool DoIsVertexArrayOES(GLuint client_id); |
| 1559 bool DoIsPathCHROMIUM(GLuint client_id); |
1554 | 1560 |
1555 // Wrapper for glLinkProgram | 1561 // Wrapper for glLinkProgram |
1556 void DoLinkProgram(GLuint program); | 1562 void DoLinkProgram(GLuint program); |
1557 | 1563 |
1558 // Wrapper for glRenderbufferStorage. | 1564 // Wrapper for glRenderbufferStorage. |
1559 void DoRenderbufferStorage( | 1565 void DoRenderbufferStorage( |
1560 GLenum target, GLenum internalformat, GLsizei width, GLsizei height); | 1566 GLenum target, GLenum internalformat, GLsizei width, GLsizei height); |
1561 | 1567 |
1562 // Handler for glRenderbufferStorageMultisampleCHROMIUM. | 1568 // Handler for glRenderbufferStorageMultisampleCHROMIUM. |
1563 void DoRenderbufferStorageMultisampleCHROMIUM( | 1569 void DoRenderbufferStorageMultisampleCHROMIUM( |
(...skipping 1757 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3321 } | 3327 } |
3322 } | 3328 } |
3323 scoped_ptr<GLuint[]> service_ids(new GLuint[n]); | 3329 scoped_ptr<GLuint[]> service_ids(new GLuint[n]); |
3324 glGenTextures(n, service_ids.get()); | 3330 glGenTextures(n, service_ids.get()); |
3325 for (GLsizei ii = 0; ii < n; ++ii) { | 3331 for (GLsizei ii = 0; ii < n; ++ii) { |
3326 CreateTexture(client_ids[ii], service_ids[ii]); | 3332 CreateTexture(client_ids[ii], service_ids[ii]); |
3327 } | 3333 } |
3328 return true; | 3334 return true; |
3329 } | 3335 } |
3330 | 3336 |
| 3337 bool GLES2DecoderImpl::GenPathsCHROMIUMHelper(GLuint first_client_id, |
| 3338 GLsizei range) { |
| 3339 GLuint last_client_id; |
| 3340 if (!SafeAddUint32(first_client_id, range - 1, &last_client_id)) { |
| 3341 return false; |
| 3342 } |
| 3343 |
| 3344 if (path_manager()->HasPathsInRange(first_client_id, last_client_id)) { |
| 3345 return false; |
| 3346 } |
| 3347 |
| 3348 GLuint first_service_id = glGenPathsNV(range); |
| 3349 if (first_service_id == 0) { |
| 3350 // We have to fail the connection here, because client has already |
| 3351 // succeeded in allocating the ids. This happens if we allocate |
| 3352 // the whole path id space (two allocations of 0x7FFFFFFF paths, for |
| 3353 // example). Currently so many allocations hang the client-side |
| 3354 // id allocator, so this should not be a practical issue. |
| 3355 return false; |
| 3356 } |
| 3357 |
| 3358 path_manager()->CreatePathRange(first_client_id, last_client_id, |
| 3359 first_service_id); |
| 3360 |
| 3361 return true; |
| 3362 } |
| 3363 |
| 3364 bool GLES2DecoderImpl::DeletePathsCHROMIUMHelper(GLuint first_client_id, |
| 3365 GLsizei range) { |
| 3366 GLuint last_client_id; |
| 3367 if (!SafeAddUint32(first_client_id, range - 1, &last_client_id)) { |
| 3368 return false; |
| 3369 } |
| 3370 |
| 3371 path_manager()->RemovePaths(first_client_id, last_client_id); |
| 3372 return true; |
| 3373 } |
| 3374 |
3331 void GLES2DecoderImpl::DeleteBuffersHelper( | 3375 void GLES2DecoderImpl::DeleteBuffersHelper( |
3332 GLsizei n, const GLuint* client_ids) { | 3376 GLsizei n, const GLuint* client_ids) { |
3333 for (GLsizei ii = 0; ii < n; ++ii) { | 3377 for (GLsizei ii = 0; ii < n; ++ii) { |
3334 Buffer* buffer = GetBuffer(client_ids[ii]); | 3378 Buffer* buffer = GetBuffer(client_ids[ii]); |
3335 if (buffer && !buffer->IsDeleted()) { | 3379 if (buffer && !buffer->IsDeleted()) { |
3336 buffer->RemoveMappedRange(); | 3380 buffer->RemoveMappedRange(); |
3337 state_.RemoveBoundBuffer(buffer); | 3381 state_.RemoveBoundBuffer(buffer); |
3338 RemoveBuffer(client_ids[ii]); | 3382 RemoveBuffer(client_ids[ii]); |
3339 } | 3383 } |
3340 } | 3384 } |
(...skipping 8371 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
11712 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, | 11756 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, |
11713 element_array_buffer ? element_array_buffer->service_id() : 0); | 11757 element_array_buffer ? element_array_buffer->service_id() : 0); |
11714 } | 11758 } |
11715 | 11759 |
11716 bool GLES2DecoderImpl::DoIsVertexArrayOES(GLuint client_id) { | 11760 bool GLES2DecoderImpl::DoIsVertexArrayOES(GLuint client_id) { |
11717 const VertexAttribManager* vao = | 11761 const VertexAttribManager* vao = |
11718 GetVertexAttribManager(client_id); | 11762 GetVertexAttribManager(client_id); |
11719 return vao && vao->IsValid() && !vao->IsDeleted(); | 11763 return vao && vao->IsValid() && !vao->IsDeleted(); |
11720 } | 11764 } |
11721 | 11765 |
| 11766 bool GLES2DecoderImpl::DoIsPathCHROMIUM(GLuint client_id) { |
| 11767 GLuint service_id = 0; |
| 11768 if (!path_manager()->GetPath(client_id, &service_id)) { |
| 11769 return false; |
| 11770 } |
| 11771 |
| 11772 return glIsPathNV(service_id); |
| 11773 } |
| 11774 |
11722 #if defined(OS_MACOSX) | 11775 #if defined(OS_MACOSX) |
11723 void GLES2DecoderImpl::ReleaseIOSurfaceForTexture(GLuint texture_id) { | 11776 void GLES2DecoderImpl::ReleaseIOSurfaceForTexture(GLuint texture_id) { |
11724 TextureToIOSurfaceMap::iterator it = texture_to_io_surface_map_.find( | 11777 TextureToIOSurfaceMap::iterator it = texture_to_io_surface_map_.find( |
11725 texture_id); | 11778 texture_id); |
11726 if (it != texture_to_io_surface_map_.end()) { | 11779 if (it != texture_to_io_surface_map_.end()) { |
11727 // Found a previous IOSurface bound to this texture; release it. | 11780 // Found a previous IOSurface bound to this texture; release it. |
11728 IOSurfaceRef surface = it->second; | 11781 IOSurfaceRef surface = it->second; |
11729 CFRelease(surface); | 11782 CFRelease(surface); |
11730 texture_to_io_surface_map_.erase(it); | 11783 texture_to_io_surface_map_.erase(it); |
11731 } | 11784 } |
(...skipping 1687 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
13419 if (CheckResetStatus()) { | 13472 if (CheckResetStatus()) { |
13420 other = error::kUnknown; | 13473 other = error::kUnknown; |
13421 } else { | 13474 } else { |
13422 // Need to lose current context before broadcasting! | 13475 // Need to lose current context before broadcasting! |
13423 MarkContextLost(error::kOutOfMemory); | 13476 MarkContextLost(error::kOutOfMemory); |
13424 } | 13477 } |
13425 group_->LoseContexts(other); | 13478 group_->LoseContexts(other); |
13426 } | 13479 } |
13427 } | 13480 } |
13428 | 13481 |
| 13482 error::Error GLES2DecoderImpl::HandleGenPathsCHROMIUM( |
| 13483 uint32 immediate_data_size, |
| 13484 const void* cmd_data) { |
| 13485 const gles2::cmds::GenPathsCHROMIUM& c = |
| 13486 *static_cast<const gles2::cmds::GenPathsCHROMIUM*>(cmd_data); |
| 13487 if (!features().chromium_path_rendering) { |
| 13488 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glGenPathsCHROMIUM", |
| 13489 "function not available"); |
| 13490 return error::kNoError; |
| 13491 } |
| 13492 |
| 13493 GLsizei range = static_cast<GLsizei>(c.range); |
| 13494 if (range < 0) { |
| 13495 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glGenPathsCHROMIUM", "range < 0"); |
| 13496 return error::kNoError; |
| 13497 } |
| 13498 |
| 13499 GLuint first_client_id = static_cast<GLuint>(c.first_client_id); |
| 13500 if (first_client_id == 0) { |
| 13501 return error::kInvalidArguments; |
| 13502 } |
| 13503 |
| 13504 if (range == 0) { |
| 13505 return error::kNoError; |
| 13506 } |
| 13507 |
| 13508 if (!GenPathsCHROMIUMHelper(first_client_id, range)) { |
| 13509 return error::kInvalidArguments; |
| 13510 } |
| 13511 |
| 13512 return error::kNoError; |
| 13513 } |
| 13514 error::Error GLES2DecoderImpl::HandleDeletePathsCHROMIUM( |
| 13515 uint32_t immediate_data_size, |
| 13516 const void* cmd_data) { |
| 13517 const gles2::cmds::DeletePathsCHROMIUM& c = |
| 13518 *static_cast<const gles2::cmds::DeletePathsCHROMIUM*>(cmd_data); |
| 13519 if (!features().chromium_path_rendering) { |
| 13520 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glGenPathsCHROMIUM", |
| 13521 "function not available"); |
| 13522 return error::kNoError; |
| 13523 } |
| 13524 |
| 13525 GLsizei range = static_cast<GLsizei>(c.range); |
| 13526 if (range < 0) { |
| 13527 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDeletePathsCHROMIUM", "range < 0"); |
| 13528 return error::kNoError; |
| 13529 } |
| 13530 |
| 13531 if (range == 0) { |
| 13532 return error::kNoError; |
| 13533 } |
| 13534 |
| 13535 GLuint first_client_id = c.first_client_id; |
| 13536 // first_client_id can be 0, because non-existing path ids are skipped. |
| 13537 |
| 13538 if (!DeletePathsCHROMIUMHelper(first_client_id, range)) { |
| 13539 return error::kInvalidArguments; |
| 13540 } |
| 13541 return error::kNoError; |
| 13542 } |
| 13543 |
| 13544 error::Error GLES2DecoderImpl::HandlePathCommandsCHROMIUM( |
| 13545 uint32 immediate_data_size, |
| 13546 const void* cmd_data) { |
| 13547 const gles2::cmds::PathCommandsCHROMIUM& c = |
| 13548 *static_cast<const gles2::cmds::PathCommandsCHROMIUM*>(cmd_data); |
| 13549 if (!features().chromium_path_rendering) { |
| 13550 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathCommandsCHROMIUM", |
| 13551 "function not available"); |
| 13552 return error::kNoError; |
| 13553 } |
| 13554 |
| 13555 GLuint service_id = 0; |
| 13556 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13557 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathCommandsCHROMIUM", |
| 13558 "invalid path name"); |
| 13559 return error::kNoError; |
| 13560 } |
| 13561 |
| 13562 GLsizei num_commands = static_cast<GLsizei>(c.numCommands); |
| 13563 if (num_commands < 0) { |
| 13564 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glPathCommandsCHROMIUM", |
| 13565 "numCommands < 0"); |
| 13566 return error::kNoError; |
| 13567 } |
| 13568 |
| 13569 GLsizei num_coords = static_cast<uint32>(c.numCoords); |
| 13570 if (num_coords < 0) { |
| 13571 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glPathCommandsCHROMIUM", |
| 13572 "numCoords < 0"); |
| 13573 return error::kNoError; |
| 13574 } |
| 13575 |
| 13576 GLenum coord_type = static_cast<uint32>(c.coordType); |
| 13577 uint32 coord_type_size = GLES2Util::GetGLTypeSizeForPathCoordType(coord_type); |
| 13578 if (!validators_->path_coord_type.IsValid(static_cast<GLint>(coord_type)) || |
| 13579 coord_type_size == 0) { |
| 13580 LOCAL_SET_GL_ERROR(GL_INVALID_ENUM, "glPathCommandsCHROMIUM", |
| 13581 "invalid coordType"); |
| 13582 return error::kNoError; |
| 13583 } |
| 13584 |
| 13585 uint32 coords_size = 0; |
| 13586 if (!SafeMultiplyUint32(num_coords, coord_type_size, &coords_size)) { |
| 13587 return error::kOutOfBounds; |
| 13588 } |
| 13589 |
| 13590 uint32 commands_shm_id = static_cast<uint32>(c.commands_shm_id); |
| 13591 uint32 commands_shm_offset = static_cast<uint32>(c.commands_shm_offset); |
| 13592 |
| 13593 const GLubyte* commands = NULL; |
| 13594 if (commands_shm_id != 0 || commands_shm_offset != 0) { |
| 13595 commands = GetSharedMemoryAs<const GLubyte*>( |
| 13596 commands_shm_id, commands_shm_offset, num_commands); |
| 13597 if (!commands) { |
| 13598 return error::kOutOfBounds; |
| 13599 } |
| 13600 } |
| 13601 |
| 13602 if (num_commands && !commands) { |
| 13603 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathCommandsCHROMIUM", |
| 13604 "missing commands"); |
| 13605 return error::kNoError; |
| 13606 } |
| 13607 |
| 13608 GLsizei num_coords_expected = 0; |
| 13609 for (GLsizei i = 0; i < num_commands; ++i) { |
| 13610 switch (commands[i]) { |
| 13611 case GL_CLOSE_PATH_CHROMIUM: |
| 13612 // Close has no coords. |
| 13613 break; |
| 13614 case GL_MOVE_TO_CHROMIUM: |
| 13615 // Fallthrough. |
| 13616 case GL_LINE_TO_CHROMIUM: |
| 13617 num_coords_expected += 2; |
| 13618 break; |
| 13619 case GL_QUADRATIC_CURVE_TO_CHROMIUM: |
| 13620 num_coords_expected += 4; |
| 13621 break; |
| 13622 case GL_CUBIC_CURVE_TO_CHROMIUM: |
| 13623 num_coords_expected += 6; |
| 13624 break; |
| 13625 case GL_CONIC_CURVE_TO_CHROMIUM: |
| 13626 num_coords_expected += 5; |
| 13627 break; |
| 13628 default: |
| 13629 LOCAL_SET_GL_ERROR(GL_INVALID_ENUM, "glPathCommandsCHROMIUM", |
| 13630 "invalid command"); |
| 13631 return error::kNoError; |
| 13632 } |
| 13633 } |
| 13634 |
| 13635 if (num_coords != num_coords_expected) { |
| 13636 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathCommandsCHROMIUM", |
| 13637 "numCoords does not match commands"); |
| 13638 return error::kNoError; |
| 13639 } |
| 13640 |
| 13641 uint32 coords_shm_id = static_cast<uint32>(c.coords_shm_id); |
| 13642 uint32 coords_shm_offset = static_cast<uint32>(c.coords_shm_offset); |
| 13643 |
| 13644 const void* coords = NULL; |
| 13645 if (coords_shm_id != 0 || coords_shm_offset != 0) { |
| 13646 coords = GetSharedMemoryAs<const void*>(coords_shm_id, coords_shm_offset, |
| 13647 coords_size); |
| 13648 if (!coords) { |
| 13649 return error::kOutOfBounds; |
| 13650 } |
| 13651 } |
| 13652 |
| 13653 if (num_coords && !coords) { |
| 13654 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathCommandsCHROMIUM", |
| 13655 "missing coords"); |
| 13656 return error::kNoError; |
| 13657 } |
| 13658 |
| 13659 glPathCommandsNV(service_id, num_commands, commands, num_coords, coord_type, |
| 13660 coords); |
| 13661 |
| 13662 return error::kNoError; |
| 13663 } |
| 13664 |
| 13665 error::Error GLES2DecoderImpl::HandlePathParameterfCHROMIUM( |
| 13666 uint32 immediate_data_size, |
| 13667 const void* cmd_data) { |
| 13668 const gles2::cmds::PathParameterfCHROMIUM& c = |
| 13669 *static_cast<const gles2::cmds::PathParameterfCHROMIUM*>(cmd_data); |
| 13670 if (!features().chromium_path_rendering) { |
| 13671 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathParameterfCHROMIUM", |
| 13672 "function not available"); |
| 13673 return error::kNoError; |
| 13674 } |
| 13675 GLuint service_id = 0; |
| 13676 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13677 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathParameterfCHROMIUM", |
| 13678 "invalid path name"); |
| 13679 return error::kNoError; |
| 13680 } |
| 13681 |
| 13682 GLenum pname = static_cast<GLenum>(c.pname); |
| 13683 GLfloat value = static_cast<GLfloat>(c.value); |
| 13684 bool hasValueError = false; |
| 13685 |
| 13686 switch (pname) { |
| 13687 case GL_PATH_STROKE_WIDTH_CHROMIUM: |
| 13688 case GL_PATH_MITER_LIMIT_CHROMIUM: |
| 13689 hasValueError = std::isnan(value) || !std::isfinite(value) || value < 0; |
| 13690 break; |
| 13691 case GL_PATH_STROKE_BOUND_CHROMIUM: |
| 13692 value = std::max(std::min(1.0f, value), 0.0f); |
| 13693 break; |
| 13694 case GL_PATH_END_CAPS_CHROMIUM: |
| 13695 hasValueError = !validators_->path_parameter_cap_values.IsValid( |
| 13696 static_cast<GLint>(value)); |
| 13697 break; |
| 13698 case GL_PATH_JOIN_STYLE_CHROMIUM: |
| 13699 hasValueError = !validators_->path_parameter_join_values.IsValid( |
| 13700 static_cast<GLint>(value)); |
| 13701 break; |
| 13702 default: |
| 13703 DCHECK(!validators_->path_parameter.IsValid(pname)); |
| 13704 LOCAL_SET_GL_ERROR_INVALID_ENUM("glPathParameterfCHROMIUM", pname, |
| 13705 "pname"); |
| 13706 return error::kNoError; |
| 13707 } |
| 13708 DCHECK(validators_->path_parameter.IsValid(pname)); |
| 13709 |
| 13710 if (hasValueError) { |
| 13711 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glPathParameterfCHROMIUM", |
| 13712 "value not correct"); |
| 13713 return error::kNoError; |
| 13714 } |
| 13715 |
| 13716 glPathParameterfNV(service_id, pname, value); |
| 13717 return error::kNoError; |
| 13718 } |
| 13719 |
| 13720 error::Error GLES2DecoderImpl::HandlePathParameteriCHROMIUM( |
| 13721 uint32 immediate_data_size, |
| 13722 const void* cmd_data) { |
| 13723 const gles2::cmds::PathParameteriCHROMIUM& c = |
| 13724 *static_cast<const gles2::cmds::PathParameteriCHROMIUM*>(cmd_data); |
| 13725 if (!features().chromium_path_rendering) { |
| 13726 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathParameteriCHROMIUM", |
| 13727 "function not available"); |
| 13728 return error::kNoError; |
| 13729 } |
| 13730 GLuint service_id = 0; |
| 13731 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13732 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glPathParameteriCHROMIUM", |
| 13733 "invalid path name"); |
| 13734 return error::kNoError; |
| 13735 } |
| 13736 |
| 13737 GLenum pname = static_cast<GLenum>(c.pname); |
| 13738 GLint value = static_cast<GLint>(c.value); |
| 13739 bool hasValueError = false; |
| 13740 |
| 13741 switch (pname) { |
| 13742 case GL_PATH_STROKE_WIDTH_CHROMIUM: |
| 13743 case GL_PATH_MITER_LIMIT_CHROMIUM: |
| 13744 hasValueError = value < 0; |
| 13745 break; |
| 13746 case GL_PATH_STROKE_BOUND_CHROMIUM: |
| 13747 value = std::max(std::min(1, value), 0); |
| 13748 break; |
| 13749 case GL_PATH_END_CAPS_CHROMIUM: |
| 13750 hasValueError = !validators_->path_parameter_cap_values.IsValid(value); |
| 13751 break; |
| 13752 case GL_PATH_JOIN_STYLE_CHROMIUM: |
| 13753 hasValueError = !validators_->path_parameter_join_values.IsValid(value); |
| 13754 break; |
| 13755 default: |
| 13756 DCHECK(!validators_->path_parameter.IsValid(pname)); |
| 13757 LOCAL_SET_GL_ERROR_INVALID_ENUM("glPathParameteriCHROMIUM", pname, |
| 13758 "pname"); |
| 13759 return error::kNoError; |
| 13760 } |
| 13761 DCHECK(validators_->path_parameter.IsValid(pname)); |
| 13762 |
| 13763 if (hasValueError) { |
| 13764 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glPathParameteriCHROMIUM", |
| 13765 "value not correct"); |
| 13766 return error::kNoError; |
| 13767 } |
| 13768 |
| 13769 glPathParameteriNV(service_id, pname, value); |
| 13770 return error::kNoError; |
| 13771 } |
| 13772 |
| 13773 error::Error GLES2DecoderImpl::HandleStencilFillPathCHROMIUM( |
| 13774 uint32 immediate_data_size, |
| 13775 const void* cmd_data) { |
| 13776 const gles2::cmds::StencilFillPathCHROMIUM& c = |
| 13777 *static_cast<const gles2::cmds::StencilFillPathCHROMIUM*>(cmd_data); |
| 13778 if (!features().chromium_path_rendering) { |
| 13779 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glStencilFillPathCHROMIUM", |
| 13780 "function not available"); |
| 13781 return error::kNoError; |
| 13782 } |
| 13783 GLenum fill_mode = static_cast<GLenum>(c.fillMode); |
| 13784 if (!validators_->path_fill_mode.IsValid(fill_mode)) { |
| 13785 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilFillPathCHROMIUM", fill_mode, |
| 13786 "fillMode"); |
| 13787 return error::kNoError; |
| 13788 } |
| 13789 GLuint mask = static_cast<GLuint>(c.mask); |
| 13790 if ((fill_mode == GL_COUNT_UP_CHROMIUM || |
| 13791 fill_mode == GL_COUNT_DOWN_CHROMIUM) && |
| 13792 GLES2Util::IsNPOT(mask + 1)) { |
| 13793 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glStencilFillPathCHROMIUM", |
| 13794 "mask is not power of two"); |
| 13795 return error::kNoError; |
| 13796 } |
| 13797 GLuint service_id = 0; |
| 13798 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13799 // "If /path/ does not name an existing path object, the command does |
| 13800 // nothing (and no error is generated)." |
| 13801 // This holds for other rendering functions, too. |
| 13802 return error::kNoError; |
| 13803 } |
| 13804 ApplyDirtyState(); |
| 13805 glStencilFillPathNV(service_id, fill_mode, mask); |
| 13806 return error::kNoError; |
| 13807 } |
| 13808 |
| 13809 error::Error GLES2DecoderImpl::HandleStencilStrokePathCHROMIUM( |
| 13810 uint32 immediate_data_size, |
| 13811 const void* cmd_data) { |
| 13812 const gles2::cmds::StencilStrokePathCHROMIUM& c = |
| 13813 *static_cast<const gles2::cmds::StencilStrokePathCHROMIUM*>(cmd_data); |
| 13814 if (!features().chromium_path_rendering) { |
| 13815 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glStencilStrokePathCHROMIUM", |
| 13816 "function not available"); |
| 13817 return error::kNoError; |
| 13818 } |
| 13819 GLuint service_id = 0; |
| 13820 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13821 return error::kNoError; |
| 13822 } |
| 13823 GLint reference = static_cast<GLint>(c.reference); |
| 13824 GLuint mask = static_cast<GLuint>(c.mask); |
| 13825 ApplyDirtyState(); |
| 13826 glStencilStrokePathNV(service_id, reference, mask); |
| 13827 return error::kNoError; |
| 13828 } |
| 13829 |
| 13830 error::Error GLES2DecoderImpl::HandleCoverFillPathCHROMIUM( |
| 13831 uint32 immediate_data_size, |
| 13832 const void* cmd_data) { |
| 13833 const gles2::cmds::CoverFillPathCHROMIUM& c = |
| 13834 *static_cast<const gles2::cmds::CoverFillPathCHROMIUM*>(cmd_data); |
| 13835 if (!features().chromium_path_rendering) { |
| 13836 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCoverFillPathCHROMIUM", |
| 13837 "function not available"); |
| 13838 return error::kNoError; |
| 13839 } |
| 13840 GLenum cover_mode = static_cast<GLenum>(c.coverMode); |
| 13841 if (!validators_->path_cover_mode.IsValid(cover_mode)) { |
| 13842 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCoverFillPathCHROMIUM", cover_mode, |
| 13843 "coverMode"); |
| 13844 return error::kNoError; |
| 13845 } |
| 13846 GLuint service_id = 0; |
| 13847 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13848 return error::kNoError; |
| 13849 } |
| 13850 |
| 13851 ApplyDirtyState(); |
| 13852 glCoverFillPathNV(service_id, cover_mode); |
| 13853 return error::kNoError; |
| 13854 } |
| 13855 |
| 13856 error::Error GLES2DecoderImpl::HandleCoverStrokePathCHROMIUM( |
| 13857 uint32 immediate_data_size, |
| 13858 const void* cmd_data) { |
| 13859 const gles2::cmds::CoverStrokePathCHROMIUM& c = |
| 13860 *static_cast<const gles2::cmds::CoverStrokePathCHROMIUM*>(cmd_data); |
| 13861 if (!features().chromium_path_rendering) { |
| 13862 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCoverStrokePathCHROMIUM", |
| 13863 "function not available"); |
| 13864 return error::kNoError; |
| 13865 } |
| 13866 GLenum cover_mode = static_cast<GLenum>(c.coverMode); |
| 13867 if (!validators_->path_cover_mode.IsValid(cover_mode)) { |
| 13868 LOCAL_SET_GL_ERROR_INVALID_ENUM("glCoverStrokePathCHROMIUM", cover_mode, |
| 13869 "coverMode"); |
| 13870 return error::kNoError; |
| 13871 } |
| 13872 GLuint service_id = 0; |
| 13873 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13874 return error::kNoError; |
| 13875 } |
| 13876 |
| 13877 ApplyDirtyState(); |
| 13878 glCoverStrokePathNV(service_id, cover_mode); |
| 13879 return error::kNoError; |
| 13880 } |
| 13881 |
| 13882 error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathCHROMIUM( |
| 13883 uint32 immediate_data_size, |
| 13884 const void* cmd_data) { |
| 13885 const gles2::cmds::StencilThenCoverFillPathCHROMIUM& c = |
| 13886 *static_cast<const gles2::cmds::StencilThenCoverFillPathCHROMIUM*>( |
| 13887 cmd_data); |
| 13888 if (!features().chromium_path_rendering) { |
| 13889 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, |
| 13890 "glStencilThenCoverFillPathCHROMIUM", |
| 13891 "function not available"); |
| 13892 return error::kNoError; |
| 13893 } |
| 13894 GLenum fill_mode = static_cast<GLenum>(c.fillMode); |
| 13895 if (!validators_->path_fill_mode.IsValid(fill_mode)) { |
| 13896 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilThenCoverFillPathCHROMIUM", |
| 13897 fill_mode, "fillMode"); |
| 13898 return error::kNoError; |
| 13899 } |
| 13900 GLuint mask = static_cast<GLuint>(c.mask); |
| 13901 if ((fill_mode == GL_COUNT_UP_CHROMIUM || |
| 13902 fill_mode == GL_COUNT_DOWN_CHROMIUM) && |
| 13903 GLES2Util::IsNPOT(mask + 1)) { |
| 13904 LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glStencilThenCoverFillPathCHROMIUM", |
| 13905 "mask is not power of two"); |
| 13906 return error::kNoError; |
| 13907 } |
| 13908 GLenum cover_mode = static_cast<GLenum>(c.coverMode); |
| 13909 if (!validators_->path_cover_mode.IsValid(cover_mode)) { |
| 13910 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilThenCoverFillPathCHROMIUM", |
| 13911 cover_mode, "coverMode"); |
| 13912 return error::kNoError; |
| 13913 } |
| 13914 GLuint service_id = 0; |
| 13915 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13916 return error::kNoError; |
| 13917 } |
| 13918 ApplyDirtyState(); |
| 13919 glStencilThenCoverFillPathNV(service_id, fill_mode, mask, cover_mode); |
| 13920 return error::kNoError; |
| 13921 } |
| 13922 |
| 13923 error::Error GLES2DecoderImpl::HandleStencilThenCoverStrokePathCHROMIUM( |
| 13924 uint32 immediate_data_size, |
| 13925 const void* cmd_data) { |
| 13926 const gles2::cmds::StencilThenCoverStrokePathCHROMIUM& c = |
| 13927 *static_cast<const gles2::cmds::StencilThenCoverStrokePathCHROMIUM*>( |
| 13928 cmd_data); |
| 13929 if (!features().chromium_path_rendering) { |
| 13930 LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, |
| 13931 "glStencilThenCoverStrokePathCHROMIUM", |
| 13932 "function not available"); |
| 13933 return error::kNoError; |
| 13934 } |
| 13935 GLenum cover_mode = static_cast<GLenum>(c.coverMode); |
| 13936 if (!validators_->path_cover_mode.IsValid(cover_mode)) { |
| 13937 LOCAL_SET_GL_ERROR_INVALID_ENUM("glStencilThenCoverStrokePathCHROMIUM", |
| 13938 cover_mode, "coverMode"); |
| 13939 return error::kNoError; |
| 13940 } |
| 13941 GLuint service_id = 0; |
| 13942 if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) { |
| 13943 return error::kNoError; |
| 13944 } |
| 13945 |
| 13946 GLint reference = static_cast<GLint>(c.reference); |
| 13947 GLuint mask = static_cast<GLuint>(c.mask); |
| 13948 ApplyDirtyState(); |
| 13949 glStencilThenCoverStrokePathNV(service_id, reference, mask, cover_mode); |
| 13950 return error::kNoError; |
| 13951 } |
| 13952 |
13429 // Include the auto-generated part of this file. We split this because it means | 13953 // Include the auto-generated part of this file. We split this because it means |
13430 // we can easily edit the non-auto generated parts right here in this file | 13954 // we can easily edit the non-auto generated parts right here in this file |
13431 // instead of having to edit some template or the code generator. | 13955 // instead of having to edit some template or the code generator. |
13432 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h" | 13956 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h" |
13433 | 13957 |
13434 } // namespace gles2 | 13958 } // namespace gles2 |
13435 } // namespace gpu | 13959 } // namespace gpu |
OLD | NEW |