| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Top-level presubmit script for Chromium. |
| |
| See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts |
| for more details about the presubmit API built into depot_tools. |
| """ |
| |
| |
| _EXCLUDED_PATHS = ( |
| r"^native_client_sdk[\\/]src[\\/]build_tools[\\/]make_rules.py", |
| r"^native_client_sdk[\\/]src[\\/]build_tools[\\/]make_simple.py", |
| r"^native_client_sdk[\\/]src[\\/]tools[\\/].*.mk", |
| r"^net[\\/]tools[\\/]spdyshark[\\/].*", |
| r"^skia[\\/].*", |
| r"^third_party[\\/]blink[\\/].*", |
| r"^third_party[\\/]breakpad[\\/].*", |
| r"^v8[\\/].*", |
| r".*MakeFile$", |
| r".+_autogen\.h$", |
| r".+[\\/]pnacl_shim\.c$", |
| r"^gpu[\\/]config[\\/].*_list_json\.cc$", |
| r"^chrome[\\/]browser[\\/]resources[\\/]pdf[\\/]index.js", |
| r"tools[\\/]md_browser[\\/].*\.css$", |
| # Test pages for Maps telemetry tests. |
| r"tools[\\/]perf[\\/]page_sets[\\/]maps_perf_test.*", |
| # Test pages for WebRTC telemetry tests. |
| r"tools[\\/]perf[\\/]page_sets[\\/]webrtc_cases.*", |
| ) |
| |
| |
| # Fragment of a regular expression that matches C++ and Objective-C++ |
| # implementation files. |
| _IMPLEMENTATION_EXTENSIONS = r'\.(cc|cpp|cxx|mm)$' |
| |
| |
| # Fragment of a regular expression that matches C++ and Objective-C++ |
| # header files. |
| _HEADER_EXTENSIONS = r'\.(h|hpp|hxx)$' |
| |
| |
| # Regular expression that matches code only used for test binaries |
| # (best effort). |
| _TEST_CODE_EXCLUDED_PATHS = ( |
| r'.*[\\/](fake_|test_|mock_).+%s' % _IMPLEMENTATION_EXTENSIONS, |
| r'.+_test_(base|support|util)%s' % _IMPLEMENTATION_EXTENSIONS, |
| r'.+_(api|browser|eg|int|perf|pixel|unit|ui)?test(_[a-z]+)?%s' % |
| _IMPLEMENTATION_EXTENSIONS, |
| r'.+_(fuzz|fuzzer)(_[a-z]+)?%s' % _IMPLEMENTATION_EXTENSIONS, |
| r'.+profile_sync_service_harness%s' % _IMPLEMENTATION_EXTENSIONS, |
| r'.*[\\/](test|tool(s)?)[\\/].*', |
| # content_shell is used for running layout tests. |
| r'content[\\/]shell[\\/].*', |
| # Non-production example code. |
| r'mojo[\\/]examples[\\/].*', |
| # Launcher for running iOS tests on the simulator. |
| r'testing[\\/]iossim[\\/]iossim\.mm$', |
| ) |
| |
| _THIRD_PARTY_EXCEPT_BLINK = 'third_party/(?!blink/)' |
| |
| _TEST_ONLY_WARNING = ( |
| 'You might be calling functions intended only for testing from\n' |
| 'production code. It is OK to ignore this warning if you know what\n' |
| 'you are doing, as the heuristics used to detect the situation are\n' |
| 'not perfect. The commit queue will not block on this warning.') |
| |
| |
| _INCLUDE_ORDER_WARNING = ( |
| 'Your #include order seems to be broken. Remember to use the right ' |
| 'collation (LC_COLLATE=C) and check\nhttps://google.github.io/styleguide/' |
| 'cppguide.html#Names_and_Order_of_Includes') |
| |
| |
| # Format: Sequence of tuples containing: |
| # * String pattern or, if starting with a slash, a regular expression. |
| # * Sequence of strings to show when the pattern matches. |
| # * Error flag. True if a match is a presubmit error, otherwise it's a warning. |
| _BANNED_JAVA_FUNCTIONS = ( |
| ( |
| 'StrictMode.allowThreadDiskReads()', |
| ( |
| 'Prefer using StrictModeContext.allowDiskReads() to using StrictMode ' |
| 'directly.', |
| ), |
| False, |
| ), |
| ( |
| 'StrictMode.allowThreadDiskWrites()', |
| ( |
| 'Prefer using StrictModeContext.allowDiskWrites() to using StrictMode ' |
| 'directly.', |
| ), |
| False, |
| ), |
| ) |
| |
| # Format: Sequence of tuples containing: |
| # * String pattern or, if starting with a slash, a regular expression. |
| # * Sequence of strings to show when the pattern matches. |
| # * Error flag. True if a match is a presubmit error, otherwise it's a warning. |
| _BANNED_OBJC_FUNCTIONS = ( |
| ( |
| 'addTrackingRect:', |
| ( |
| 'The use of -[NSView addTrackingRect:owner:userData:assumeInside:] is' |
| 'prohibited. Please use CrTrackingArea instead.', |
| 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts', |
| ), |
| False, |
| ), |
| ( |
| r'/NSTrackingArea\W', |
| ( |
| 'The use of NSTrackingAreas is prohibited. Please use CrTrackingArea', |
| 'instead.', |
| 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts', |
| ), |
| False, |
| ), |
| ( |
| 'convertPointFromBase:', |
| ( |
| 'The use of -[NSView convertPointFromBase:] is almost certainly wrong.', |
| 'Please use |convertPoint:(point) fromView:nil| instead.', |
| 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts', |
| ), |
| True, |
| ), |
| ( |
| 'convertPointToBase:', |
| ( |
| 'The use of -[NSView convertPointToBase:] is almost certainly wrong.', |
| 'Please use |convertPoint:(point) toView:nil| instead.', |
| 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts', |
| ), |
| True, |
| ), |
| ( |
| 'convertRectFromBase:', |
| ( |
| 'The use of -[NSView convertRectFromBase:] is almost certainly wrong.', |
| 'Please use |convertRect:(point) fromView:nil| instead.', |
| 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts', |
| ), |
| True, |
| ), |
| ( |
| 'convertRectToBase:', |
| ( |
| 'The use of -[NSView convertRectToBase:] is almost certainly wrong.', |
| 'Please use |convertRect:(point) toView:nil| instead.', |
| 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts', |
| ), |
| True, |
| ), |
| ( |
| 'convertSizeFromBase:', |
| ( |
| 'The use of -[NSView convertSizeFromBase:] is almost certainly wrong.', |
| 'Please use |convertSize:(point) fromView:nil| instead.', |
| 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts', |
| ), |
| True, |
| ), |
| ( |
| 'convertSizeToBase:', |
| ( |
| 'The use of -[NSView convertSizeToBase:] is almost certainly wrong.', |
| 'Please use |convertSize:(point) toView:nil| instead.', |
| 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts', |
| ), |
| True, |
| ), |
| ( |
| r"/\s+UTF8String\s*]", |
| ( |
| 'The use of -[NSString UTF8String] is dangerous as it can return null', |
| 'even if |canBeConvertedToEncoding:NSUTF8StringEncoding| returns YES.', |
| 'Please use |SysNSStringToUTF8| instead.', |
| ), |
| True, |
| ), |
| ( |
| r'__unsafe_unretained', |
| ( |
| 'The use of __unsafe_unretained is almost certainly wrong, unless', |
| 'when interacting with NSFastEnumeration or NSInvocation.', |
| 'Please use __weak in files build with ARC, nothing otherwise.', |
| ), |
| False, |
| ), |
| ) |
| |
| # Format: Sequence of tuples containing: |
| # * String pattern or, if starting with a slash, a regular expression. |
| # * Sequence of strings to show when the pattern matches. |
| # * Error flag. True if a match is a presubmit error, otherwise it's a warning. |
| _BANNED_IOS_OBJC_FUNCTIONS = ( |
| ( |
| r'/\bTEST[(]', |
| ( |
| 'TEST() macro should not be used in Objective-C++ code as it does not ', |
| 'drain the autorelease pool at the end of the test. Use TEST_F() ', |
| 'macro instead with a fixture inheriting from PlatformTest (or a ', |
| 'typedef).' |
| ), |
| True, |
| ), |
| ( |
| r'/\btesting::Test\b', |
| ( |
| 'testing::Test should not be used in Objective-C++ code as it does ', |
| 'not drain the autorelease pool at the end of the test. Use ', |
| 'PlatformTest instead.' |
| ), |
| True, |
| ), |
| ) |
| |
| |
| # Format: Sequence of tuples containing: |
| # * String pattern or, if starting with a slash, a regular expression. |
| # * Sequence of strings to show when the pattern matches. |
| # * Error flag. True if a match is a presubmit error, otherwise it's a warning. |
| # * Sequence of paths to *not* check (regexps). |
| _BANNED_CPP_FUNCTIONS = ( |
| ( |
| r'\bNULL\b', |
| ( |
| 'New code should not use NULL. Use nullptr instead.', |
| ), |
| True, |
| (), |
| ), |
| # Make sure that gtest's FRIEND_TEST() macro is not used; the |
| # FRIEND_TEST_ALL_PREFIXES() macro from base/gtest_prod_util.h should be |
| # used instead since that allows for FLAKY_ and DISABLED_ prefixes. |
| ( |
| 'FRIEND_TEST(', |
| ( |
| 'Chromium code should not use gtest\'s FRIEND_TEST() macro. Include', |
| 'base/gtest_prod_util.h and use FRIEND_TEST_ALL_PREFIXES() instead.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'XSelectInput|CWEventMask|XCB_CW_EVENT_MASK', |
| ( |
| 'Chrome clients wishing to select events on X windows should use', |
| 'ui::XScopedEventSelector. It is safe to ignore this warning only if', |
| 'you are selecting events from the GPU process, or if you are using', |
| 'an XDisplay other than gfx::GetXDisplay().', |
| ), |
| True, |
| ( |
| r"^ui[\\/]gl[\\/].*\.cc$", |
| r"^media[\\/]gpu[\\/].*\.cc$", |
| r"^gpu[\\/].*\.cc$", |
| ), |
| ), |
| ( |
| r'XInternAtom|xcb_intern_atom', |
| ( |
| 'Use gfx::GetAtom() instead of interning atoms directly.', |
| ), |
| True, |
| ( |
| r"^gpu[\\/]ipc[\\/]service[\\/]gpu_watchdog_thread\.cc$", |
| r"^remoting[\\/]host[\\/]linux[\\/]x_server_clipboard\.cc$", |
| r"^ui[\\/]gfx[\\/]x[\\/]x11_atom_cache\.cc$", |
| ), |
| ), |
| ( |
| 'setMatrixClip', |
| ( |
| 'Overriding setMatrixClip() is prohibited; ', |
| 'the base function is deprecated. ', |
| ), |
| True, |
| (), |
| ), |
| ( |
| 'SkRefPtr', |
| ( |
| 'The use of SkRefPtr is prohibited. ', |
| 'Please use sk_sp<> instead.' |
| ), |
| True, |
| (), |
| ), |
| ( |
| 'SkAutoRef', |
| ( |
| 'The indirect use of SkRefPtr via SkAutoRef is prohibited. ', |
| 'Please use sk_sp<> instead.' |
| ), |
| True, |
| (), |
| ), |
| ( |
| 'SkAutoTUnref', |
| ( |
| 'The use of SkAutoTUnref is dangerous because it implicitly ', |
| 'converts to a raw pointer. Please use sk_sp<> instead.' |
| ), |
| True, |
| (), |
| ), |
| ( |
| 'SkAutoUnref', |
| ( |
| 'The indirect use of SkAutoTUnref through SkAutoUnref is dangerous ', |
| 'because it implicitly converts to a raw pointer. ', |
| 'Please use sk_sp<> instead.' |
| ), |
| True, |
| (), |
| ), |
| ( |
| r'/HANDLE_EINTR\(.*close', |
| ( |
| 'HANDLE_EINTR(close) is invalid. If close fails with EINTR, the file', |
| 'descriptor will be closed, and it is incorrect to retry the close.', |
| 'Either call close directly and ignore its return value, or wrap close', |
| 'in IGNORE_EINTR to use its return value. See http://crbug.com/269623' |
| ), |
| True, |
| (), |
| ), |
| ( |
| r'/IGNORE_EINTR\((?!.*close)', |
| ( |
| 'IGNORE_EINTR is only valid when wrapping close. To wrap other system', |
| 'calls, use HANDLE_EINTR. See http://crbug.com/269623', |
| ), |
| True, |
| ( |
| # Files that #define IGNORE_EINTR. |
| r'^base[\\/]posix[\\/]eintr_wrapper\.h$', |
| r'^ppapi[\\/]tests[\\/]test_broker\.cc$', |
| ), |
| ), |
| ( |
| r'/v8::Extension\(', |
| ( |
| 'Do not introduce new v8::Extensions into the code base, use', |
| 'gin::Wrappable instead. See http://crbug.com/334679', |
| ), |
| True, |
| ( |
| r'extensions[\\/]renderer[\\/]safe_builtins\.*', |
| ), |
| ), |
| ( |
| '#pragma comment(lib,', |
| ( |
| 'Specify libraries to link with in build files and not in the source.', |
| ), |
| True, |
| ( |
| r'^base[\\/]third_party[\\/]symbolize[\\/].*', |
| r'^third_party[\\/]abseil-cpp[\\/].*', |
| ), |
| ), |
| ( |
| r'/base::SequenceChecker\b', |
| ( |
| 'Consider using SEQUENCE_CHECKER macros instead of the class directly.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'/base::ThreadChecker\b', |
| ( |
| 'Consider using THREAD_CHECKER macros instead of the class directly.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'/(Time(|Delta|Ticks)|ThreadTicks)::FromInternalValue|ToInternalValue', |
| ( |
| 'base::TimeXXX::FromInternalValue() and ToInternalValue() are', |
| 'deprecated (http://crbug.com/634507). Please avoid converting away', |
| 'from the Time types in Chromium code, especially if any math is', |
| 'being done on time values. For interfacing with platform/library', |
| 'APIs, use FromMicroseconds() or InMicroseconds(), or one of the other', |
| 'type converter methods instead. For faking TimeXXX values (for unit', |
| 'testing only), use TimeXXX() + TimeDelta::FromMicroseconds(N). For', |
| 'other use cases, please contact base/time/OWNERS.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| 'CallJavascriptFunctionUnsafe', |
| ( |
| "Don't use CallJavascriptFunctionUnsafe() in new code. Instead, use", |
| 'AllowJavascript(), OnJavascriptAllowed()/OnJavascriptDisallowed(),', |
| 'and CallJavascriptFunction(). See https://goo.gl/qivavq.', |
| ), |
| False, |
| ( |
| r'^content[\\/]browser[\\/]webui[\\/]web_ui_impl\.(cc|h)$', |
| r'^content[\\/]public[\\/]browser[\\/]web_ui\.h$', |
| r'^content[\\/]public[\\/]test[\\/]test_web_ui\.(cc|h)$', |
| ), |
| ), |
| ( |
| 'leveldb::DB::Open', |
| ( |
| 'Instead of leveldb::DB::Open() use leveldb_env::OpenDB() from', |
| 'third_party/leveldatabase/env_chromium.h. It exposes databases to', |
| "Chrome's tracing, making their memory usage visible.", |
| ), |
| True, |
| ( |
| r'^third_party/leveldatabase/.*\.(cc|h)$', |
| ), |
| ), |
| ( |
| 'leveldb::NewMemEnv', |
| ( |
| 'Instead of leveldb::NewMemEnv() use leveldb_chrome::NewMemEnv() from', |
| 'third_party/leveldatabase/leveldb_chrome.h. It exposes environments', |
| "to Chrome's tracing, making their memory usage visible.", |
| ), |
| True, |
| ( |
| r'^third_party/leveldatabase/.*\.(cc|h)$', |
| ), |
| ), |
| ( |
| 'RunLoop::QuitCurrent', |
| ( |
| 'Please migrate away from RunLoop::QuitCurrent*() methods. Use member', |
| 'methods of a specific RunLoop instance instead.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| 'base::ScopedMockTimeMessageLoopTaskRunner', |
| ( |
| 'ScopedMockTimeMessageLoopTaskRunner is deprecated. Prefer', |
| 'ScopedTaskEnvironment::MainThreadType::MOCK_TIME. There are still a', |
| 'few cases that may require a ScopedMockTimeMessageLoopTaskRunner', |
| '(i.e. mocking the main MessageLoopForUI in browser_tests), but check', |
| 'with gab@ first if you think you need it)', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'std::regex', |
| ( |
| 'Using std::regex adds unnecessary binary size to Chrome. Please use', |
| 're2::RE2 instead (crbug.com/755321)', |
| ), |
| True, |
| (), |
| ), |
| ( |
| r'/\bstd::to_string\b', |
| ( |
| 'std::to_string is locale dependent and slower than alternatives.', |
| 'For locale-independent strings, e.g. writing numbers to and from', |
| 'disk profiles, use base::NumberToString().', |
| 'For user-visible strings, use base::FormatNumber() and', |
| 'the related functions in base/i18n/number_formatting.h.', |
| ), |
| False, # Only a warning for now since it is already used, |
| [_THIRD_PARTY_EXCEPT_BLINK], # Don't warn in third_party folders. |
| ), |
| ( |
| r'/\bstd::shared_ptr\b', |
| ( |
| 'std::shared_ptr should not be used. Use scoped_refptr instead.', |
| ), |
| True, |
| [_THIRD_PARTY_EXCEPT_BLINK], # Not an error in third_party folders. |
| ), |
| ( |
| r'/\blong long\b', |
| ( |
| 'long long is banned. Use stdint.h if you need a 64 bit number.', |
| ), |
| False, # Only a warning since it is already used. |
| [_THIRD_PARTY_EXCEPT_BLINK], # Don't warn in third_party folders. |
| ), |
| ( |
| r'/\bstd::bind\b', |
| ( |
| 'std::bind is banned because of lifetime risks.', |
| 'Use base::BindOnce or base::BindRepeating instead.', |
| ), |
| True, |
| [_THIRD_PARTY_EXCEPT_BLINK], # Not an error in third_party folders. |
| ), |
| ( |
| r'/\b#include <chrono>\b', |
| ( |
| '<chrono> overlaps with Time APIs in base. Keep using', |
| 'base classes.', |
| ), |
| True, |
| [_THIRD_PARTY_EXCEPT_BLINK], # Not an error in third_party folders. |
| ), |
| ( |
| r'/\b#include <exception>\b', |
| ( |
| 'Exceptions are banned and disabled in Chromium.', |
| ), |
| True, |
| [_THIRD_PARTY_EXCEPT_BLINK], # Not an error in third_party folders. |
| ), |
| ( |
| r'/\bstd::function\b', |
| ( |
| 'std::function is banned. Instead use base::Callback which directly', |
| 'supports Chromium\'s weak pointers, ref counting and more.', |
| ), |
| False, # Only a warning since there are dozens of uses already. |
| [_THIRD_PARTY_EXCEPT_BLINK], # Do not warn in third_party folders. |
| ), |
| ( |
| r'/\b#include <random>\b', |
| ( |
| 'Do not use any random number engines from <random>. Instead', |
| 'use base::RandomBitGenerator.', |
| ), |
| True, |
| [_THIRD_PARTY_EXCEPT_BLINK], # Not an error in third_party folders. |
| ), |
| ( |
| r'/\bstd::ratio\b', |
| ( |
| 'std::ratio is banned by the Google Style Guide.', |
| ), |
| True, |
| [_THIRD_PARTY_EXCEPT_BLINK], # Not an error in third_party folders. |
| ), |
| ( |
| (r'/base::ThreadRestrictions::(ScopedAllowIO|AssertIOAllowed|' |
| r'DisallowWaiting|AssertWaitAllowed|SetWaitAllowed|ScopedAllowWait)'), |
| ( |
| 'Use the new API in base/threading/thread_restrictions.h.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'/\bbase::Bind\(', |
| ( |
| 'Please consider using base::Bind{Once,Repeating} instead', |
| 'of base::Bind. (crbug.com/714018)', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'/\bbase::Callback<', |
| ( |
| 'Please consider using base::{Once,Repeating}Callback instead', |
| 'of base::Callback. (crbug.com/714018)', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'/\bbase::Closure\b', |
| ( |
| 'Please consider using base::{Once,Repeating}Closure instead', |
| 'of base::Closure. (crbug.com/714018)', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'/base::SharedMemory(|Handle)', |
| ( |
| 'base::SharedMemory is deprecated. Please use', |
| '{Writable,ReadOnly}SharedMemoryRegion instead.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'RunMessageLoop', |
| ( |
| 'RunMessageLoop is deprecated, use RunLoop instead.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'RunThisRunLoop', |
| ( |
| 'RunThisRunLoop is deprecated, use RunLoop directly instead.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'RunAllPendingInMessageLoop()', |
| ( |
| "Prefer RunLoop over RunAllPendingInMessageLoop, please contact gab@", |
| "if you're convinced you need this.", |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'RunAllPendingInMessageLoop(BrowserThread', |
| ( |
| 'RunAllPendingInMessageLoop is deprecated. Use RunLoop for', |
| 'BrowserThread::UI, TestBrowserThreadBundle::RunIOThreadUntilIdle', |
| 'for BrowserThread::IO, and prefer RunLoop::QuitClosure to observe', |
| 'async events instead of flushing threads.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'MessageLoopRunner', |
| ( |
| 'MessageLoopRunner is deprecated, use RunLoop instead.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| r'GetDeferredQuitTaskForRunLoop', |
| ( |
| "GetDeferredQuitTaskForRunLoop shouldn't be needed, please contact", |
| "gab@ if you found a use case where this is the only solution.", |
| ), |
| False, |
| (), |
| ), |
| ( |
| 'sqlite3_initialize(', |
| ( |
| 'Instead of calling sqlite3_initialize(), depend on //sql, ', |
| '#include "sql/initialize.h" and use sql::EnsureSqliteInitialized().', |
| ), |
| True, |
| ( |
| r'^sql/initialization\.(cc|h)$', |
| r'^third_party/sqlite/.*\.(c|cc|h)$', |
| ), |
| ), |
| ( |
| 'net::URLFetcher', |
| ( |
| 'net::URLFetcher should no longer be used in content embedders. ', |
| 'Instead, use network::SimpleURLLoader instead, which supports ', |
| 'an out-of-process network stack. ', |
| 'net::URLFetcher may still be used in binaries that do not embed', |
| 'content.', |
| ), |
| False, |
| ( |
| r'^ios[\\/].*\.(cc|h)$', |
| r'.*[\\/]ios[\\/].*\.(cc|h)$', |
| r'.*_ios\.(cc|h)$', |
| r'^net[\\/].*\.(cc|h)$', |
| r'.*[\\/]tools[\\/].*\.(cc|h)$', |
| ), |
| ), |
| ( |
| r'std::random_shuffle', |
| ( |
| 'std::random_shuffle is deprecated in C++14, and removed in C++17. Use', |
| 'base::RandomShuffle instead.' |
| ), |
| True, |
| (), |
| ), |
| ( |
| 'ios/web/public/test/http_server', |
| ( |
| 'web::HTTPserver is deprecated use net::EmbeddedTestServer instead.', |
| ), |
| False, |
| (), |
| ), |
| ( |
| 'GetAddressOf', |
| ( |
| 'Improper use of Microsoft::WRL::ComPtr<T>::GetAddressOf() has been ', |
| 'implicated in a few leaks. Use operator& instead.' |
| ), |
| True, |
| (), |
| ), |
| ( |
| 'DEFINE_TYPE_CASTS', |
| ( |
| 'DEFINE_TYPE_CASTS is deprecated. Instead, use downcast helpers from ', |
| '//third_party/blink/renderer/platform/casting.h.' |
| ), |
| True, |
| ( |
| r'^third_party/blink/renderer/.*\.(cc|h)$', |
| ), |
| ), |
| ( |
| r'/\bmojo::DataPipe\b', |
| ( |
| 'mojo::DataPipe is deprecated. Use mojo::CreateDataPipe instead.', |
| ), |
| True, |
| (), |
| ), |
| ) |
| |
| |
| _IPC_ENUM_TRAITS_DEPRECATED = ( |
| 'You are using IPC_ENUM_TRAITS() in your code. It has been deprecated.\n' |
| 'See http://www.chromium.org/Home/chromium-security/education/' |
| 'security-tips-for-ipc') |
| |
| _LONG_PATH_ERROR = ( |
| 'Some files included in this CL have file names that are too long (> 200' |
| ' characters). If committed, these files will cause issues on Windows. See' |
| ' https://crbug.com/612667 for more details.' |
| ) |
| |
| _JAVA_MULTIPLE_DEFINITION_EXCLUDED_PATHS = [ |
| r".*[\\/]BuildHooksAndroidImpl\.java", |
| r".*[\\/]LicenseContentProvider\.java", |
| r".*[\\/]PlatformServiceBridgeImpl.java", |
| r".*chrome[\\\/]android[\\\/]feed[\\\/]dummy[\\\/].*\.java", |
| ] |
| |
| # These paths contain test data and other known invalid JSON files. |
| _KNOWN_INVALID_JSON_FILE_PATTERNS = [ |
| r'test[\\/]data[\\/]', |
| r'^components[\\/]policy[\\/]resources[\\/]policy_templates\.json$', |
| r'^third_party[\\/]protobuf[\\/]', |
| r'^third_party[\\/]blink[\\/]renderer[\\/]devtools[\\/]protocol\.json$', |
| r'^third_party[\\/]blink[\\/]web_tests[\\/]external[\\/]wpt[\\/]', |
| ] |
| |
| |
| _VALID_OS_MACROS = ( |
| # Please keep sorted. |
| 'OS_AIX', |
| 'OS_ANDROID', |
| 'OS_ASMJS', |
| 'OS_BSD', |
| 'OS_CAT', # For testing. |
| 'OS_CHROMEOS', |
| 'OS_CYGWIN', # third_party code. |
| 'OS_FREEBSD', |
| 'OS_FUCHSIA', |
| 'OS_IOS', |
| 'OS_LINUX', |
| 'OS_MACOSX', |
| 'OS_NACL', |
| 'OS_NACL_NONSFI', |
| 'OS_NACL_SFI', |
| 'OS_NETBSD', |
| 'OS_OPENBSD', |
| 'OS_POSIX', |
| 'OS_QNX', |
| 'OS_SOLARIS', |
| 'OS_WIN', |
| ) |
| |
| |
| _ANDROID_SPECIFIC_PYDEPS_FILES = [ |
| 'android_webview/tools/run_cts.pydeps', |
| 'base/android/jni_generator/jni_generator.pydeps', |
| 'base/android/jni_generator/jni_registration_generator.pydeps', |
| 'build/android/devil_chromium.pydeps', |
| 'build/android/gyp/aar.pydeps', |
| 'build/android/gyp/aidl.pydeps', |
| 'build/android/gyp/apkbuilder.pydeps', |
| 'build/android/gyp/assert_static_initializers.pydeps', |
| 'build/android/gyp/bytecode_processor.pydeps', |
| 'build/android/gyp/compile_resources.pydeps', |
| 'build/android/gyp/create_app_bundle_minimal_apks.pydeps', |
| 'build/android/gyp/create_bundle_wrapper_script.pydeps', |
| 'build/android/gyp/copy_ex.pydeps', |
| 'build/android/gyp/create_app_bundle.pydeps', |
| 'build/android/gyp/create_apk_operations_script.pydeps', |
| 'build/android/gyp/create_java_binary_script.pydeps', |
| 'build/android/gyp/create_size_info_files.pydeps', |
| 'build/android/gyp/create_stack_script.pydeps', |
| 'build/android/gyp/create_tool_wrapper.pydeps', |
| 'build/android/gyp/desugar.pydeps', |
| 'build/android/gyp/dexsplitter.pydeps', |
| 'build/android/gyp/dex.pydeps', |
| 'build/android/gyp/dist_aar.pydeps', |
| 'build/android/gyp/emma_instr.pydeps', |
| 'build/android/gyp/filter_zip.pydeps', |
| 'build/android/gyp/gcc_preprocess.pydeps', |
| 'build/android/gyp/generate_linker_version_script.pydeps', |
| 'build/android/gyp/ijar.pydeps', |
| 'build/android/gyp/java_cpp_enum.pydeps', |
| 'build/android/gyp/java_cpp_strings.pydeps', |
| 'build/android/gyp/javac.pydeps', |
| 'build/android/gyp/jinja_template.pydeps', |
| 'build/android/gyp/lint.pydeps', |
| 'build/android/gyp/main_dex_list.pydeps', |
| 'build/android/gyp/merge_manifest.pydeps', |
| 'build/android/gyp/prepare_resources.pydeps', |
| 'build/android/gyp/proguard.pydeps', |
| 'build/android/gyp/write_build_config.pydeps', |
| 'build/android/gyp/write_ordered_libraries.pydeps', |
| 'build/android/gyp/zip.pydeps', |
| 'build/android/incremental_install/generate_android_manifest.pydeps', |
| 'build/android/incremental_install/write_installer_json.pydeps', |
| 'build/android/resource_sizes.pydeps', |
| 'build/android/test_runner.pydeps', |
| 'build/android/test_wrapper/logdog_wrapper.pydeps', |
| 'build/protoc_java.pydeps', |
| 'net/tools/testserver/testserver.pydeps', |
| 'third_party/android_platform/development/scripts/stack.pydeps', |
| ] |
| |
| |
| _GENERIC_PYDEPS_FILES = [ |
| 'chrome/test/chromedriver/test/run_py_tests.pydeps', |
| 'chrome/test/chromedriver/log_replay/client_replay_unittest.pydeps', |
| 'tools/binary_size/supersize.pydeps', |
| ] |
| |
| |
| _ALL_PYDEPS_FILES = _ANDROID_SPECIFIC_PYDEPS_FILES + _GENERIC_PYDEPS_FILES |
| |
| |
| # Bypass the AUTHORS check for these accounts. |
| _KNOWN_ROBOTS = set( |
| '%s-chromium-autoroll@skia-buildbots.google.com.iam.gserviceaccount.com' % s |
| for s in ('afdo', 'angle', 'catapult', 'chromite', 'depot-tools', |
| 'fuchsia-sdk', 'nacl', 'pdfium', 'perfetto', 'skia', |
| 'spirv', 'src-internal', 'webrtc') |
| ) | set('%s@appspot.gserviceaccount.com' % s for s in ('findit-for-me',) |
| ) | set('%s@developer.gserviceaccount.com' % s for s in ('3su6n15k.default',) |
| ) | set('%s@chops-service-accounts.iam.gserviceaccount.com' % s |
| for s in ('v8-ci-autoroll-builder', 'wpt-autoroller',) |
| ) | set('%s@skia-public.iam.gserviceaccount.com' % s |
| for s in ('chromium-autoroll',) |
| ) | set('%s@skia-corp.google.com.iam.gserviceaccount.com' % s |
| for s in ('chromium-internal-autoroll',)) |
| |
| |
| def _CheckNoProductionCodeUsingTestOnlyFunctions(input_api, output_api): |
| """Attempts to prevent use of functions intended only for testing in |
| non-testing code. For now this is just a best-effort implementation |
| that ignores header files and may have some false positives. A |
| better implementation would probably need a proper C++ parser. |
| """ |
| # We only scan .cc files and the like, as the declaration of |
| # for-testing functions in header files are hard to distinguish from |
| # calls to such functions without a proper C++ parser. |
| file_inclusion_pattern = [r'.+%s' % _IMPLEMENTATION_EXTENSIONS] |
| |
| base_function_pattern = r'[ :]test::[^\s]+|ForTest(s|ing)?|for_test(s|ing)?' |
| inclusion_pattern = input_api.re.compile(r'(%s)\s*\(' % base_function_pattern) |
| comment_pattern = input_api.re.compile(r'//.*(%s)' % base_function_pattern) |
| exclusion_pattern = input_api.re.compile( |
| r'::[A-Za-z0-9_]+(%s)|(%s)[^;]+\{' % ( |
| base_function_pattern, base_function_pattern)) |
| |
| def FilterFile(affected_file): |
| black_list = (_EXCLUDED_PATHS + |
| _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST) |
| return input_api.FilterSourceFile( |
| affected_file, |
| white_list=file_inclusion_pattern, |
| black_list=black_list) |
| |
| problems = [] |
| for f in input_api.AffectedSourceFiles(FilterFile): |
| local_path = f.LocalPath() |
| for line_number, line in f.ChangedContents(): |
| if (inclusion_pattern.search(line) and |
| not comment_pattern.search(line) and |
| not exclusion_pattern.search(line)): |
| problems.append( |
| '%s:%d\n %s' % (local_path, line_number, line.strip())) |
| |
| if problems: |
| return [output_api.PresubmitPromptOrNotify(_TEST_ONLY_WARNING, problems)] |
| else: |
| return [] |
| |
| |
| def _CheckNoProductionCodeUsingTestOnlyFunctionsJava(input_api, output_api): |
| """This is a simplified version of |
| _CheckNoProductionCodeUsingTestOnlyFunctions for Java files. |
| """ |
| javadoc_start_re = input_api.re.compile(r'^\s*/\*\*') |
| javadoc_end_re = input_api.re.compile(r'^\s*\*/') |
| name_pattern = r'ForTest(s|ing)?' |
| # Describes an occurrence of "ForTest*" inside a // comment. |
| comment_re = input_api.re.compile(r'//.*%s' % name_pattern) |
| # Catch calls. |
| inclusion_re = input_api.re.compile(r'(%s)\s*\(' % name_pattern) |
| # Ignore definitions. (Comments are ignored separately.) |
| exclusion_re = input_api.re.compile(r'(%s)[^;]+\{' % name_pattern) |
| |
| problems = [] |
| sources = lambda x: input_api.FilterSourceFile( |
| x, |
| black_list=(('(?i).*test', r'.*\/junit\/') |
| + input_api.DEFAULT_BLACK_LIST), |
| white_list=[r'.*\.java$'] |
| ) |
| for f in input_api.AffectedFiles(include_deletes=False, file_filter=sources): |
| local_path = f.LocalPath() |
| is_inside_javadoc = False |
| for line_number, line in f.ChangedContents(): |
| if is_inside_javadoc and javadoc_end_re.search(line): |
| is_inside_javadoc = False |
| if not is_inside_javadoc and javadoc_start_re.search(line): |
| is_inside_javadoc = True |
| if is_inside_javadoc: |
| continue |
| if (inclusion_re.search(line) and |
| not comment_re.search(line) and |
| not exclusion_re.search(line)): |
| problems.append( |
| '%s:%d\n %s' % (local_path, line_number, line.strip())) |
| |
| if problems: |
| return [output_api.PresubmitPromptOrNotify(_TEST_ONLY_WARNING, problems)] |
| else: |
| return [] |
| |
| |
| def _CheckNoIOStreamInHeaders(input_api, output_api): |
| """Checks to make sure no .h files include <iostream>.""" |
| files = [] |
| pattern = input_api.re.compile(r'^#include\s*<iostream>', |
| input_api.re.MULTILINE) |
| for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile): |
| if not f.LocalPath().endswith('.h'): |
| continue |
| contents = input_api.ReadFile(f) |
| if pattern.search(contents): |
| files.append(f) |
| |
| if len(files): |
| return [output_api.PresubmitError( |
| 'Do not #include <iostream> in header files, since it inserts static ' |
| 'initialization into every file including the header. Instead, ' |
| '#include <ostream>. See http://crbug.com/94794', |
| files) ] |
| return [] |
| |
| def _CheckNoStrCatRedefines(input_api, output_api): |
| """Checks no windows headers with StrCat redefined are included directly.""" |
| files = [] |
| pattern_deny = input_api.re.compile( |
| r'^#include\s*[<"](shlwapi|atlbase|propvarutil|sphelper).h[">]', |
| input_api.re.MULTILINE) |
| pattern_allow = input_api.re.compile( |
| r'^#include\s"base/win/windows_defines.inc"', |
| input_api.re.MULTILINE) |
| for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile): |
| contents = input_api.ReadFile(f) |
| if pattern_deny.search(contents) and not pattern_allow.search(contents): |
| files.append(f.LocalPath()) |
| |
| if len(files): |
| return [output_api.PresubmitError( |
| 'Do not #include shlwapi.h, atlbase.h, propvarutil.h or sphelper.h ' |
| 'directly since they pollute code with StrCat macro. Instead, ' |
| 'include matching header from base/win. See http://crbug.com/856536', |
| files) ] |
| return [] |
| |
| |
| def _CheckNoUNIT_TESTInSourceFiles(input_api, output_api): |
| """Checks to make sure no source files use UNIT_TEST.""" |
| problems = [] |
| for f in input_api.AffectedFiles(): |
| if (not f.LocalPath().endswith(('.cc', '.mm'))): |
| continue |
| |
| for line_num, line in f.ChangedContents(): |
| if 'UNIT_TEST ' in line or line.endswith('UNIT_TEST'): |
| problems.append(' %s:%d' % (f.LocalPath(), line_num)) |
| |
| if not problems: |
| return [] |
| return [output_api.PresubmitPromptWarning('UNIT_TEST is only for headers.\n' + |
| '\n'.join(problems))] |
| |
| def _CheckNoDISABLETypoInTests(input_api, output_api): |
| """Checks to prevent attempts to disable tests with DISABLE_ prefix. |
| |
| This test warns if somebody tries to disable a test with the DISABLE_ prefix |
| instead of DISABLED_. To filter false positives, reports are only generated |
| if a corresponding MAYBE_ line exists. |
| """ |
| problems = [] |
| |
| # The following two patterns are looked for in tandem - is a test labeled |
| # as MAYBE_ followed by a DISABLE_ (instead of the correct DISABLED) |
| maybe_pattern = input_api.re.compile(r'MAYBE_([a-zA-Z0-9_]+)') |
| disable_pattern = input_api.re.compile(r'DISABLE_([a-zA-Z0-9_]+)') |
| |
| # This is for the case that a test is disabled on all platforms. |
| full_disable_pattern = input_api.re.compile( |
| r'^\s*TEST[^(]*\([a-zA-Z0-9_]+,\s*DISABLE_[a-zA-Z0-9_]+\)', |
| input_api.re.MULTILINE) |
| |
| for f in input_api.AffectedFiles(False): |
| if not 'test' in f.LocalPath() or not f.LocalPath().endswith('.cc'): |
| continue |
| |
| # Search for MABYE_, DISABLE_ pairs. |
| disable_lines = {} # Maps of test name to line number. |
| maybe_lines = {} |
| for line_num, line in f.ChangedContents(): |
| disable_match = disable_pattern.search(line) |
| if disable_match: |
| disable_lines[disable_match.group(1)] = line_num |
| maybe_match = maybe_pattern.search(line) |
| if maybe_match: |
| maybe_lines[maybe_match.group(1)] = line_num |
| |
| # Search for DISABLE_ occurrences within a TEST() macro. |
| disable_tests = set(disable_lines.keys()) |
| maybe_tests = set(maybe_lines.keys()) |
| for test in disable_tests.intersection(maybe_tests): |
| problems.append(' %s:%d' % (f.LocalPath(), disable_lines[test])) |
| |
| contents = input_api.ReadFile(f) |
| full_disable_match = full_disable_pattern.search(contents) |
| if full_disable_match: |
| problems.append(' %s' % f.LocalPath()) |
| |
| if not problems: |
| return [] |
| return [ |
| output_api.PresubmitPromptWarning( |
| 'Attempt to disable a test with DISABLE_ instead of DISABLED_?\n' + |
| '\n'.join(problems)) |
| ] |
| |
| |
| def _CheckDCHECK_IS_ONHasBraces(input_api, output_api): |
| """Checks to make sure DCHECK_IS_ON() does not skip the parentheses.""" |
| errors = [] |
| pattern = input_api.re.compile(r'DCHECK_IS_ON(?!\(\))', |
| input_api.re.MULTILINE) |
| for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile): |
| if (not f.LocalPath().endswith(('.cc', '.mm', '.h'))): |
| continue |
| for lnum, line in f.ChangedContents(): |
| if input_api.re.search(pattern, line): |
| errors.append(output_api.PresubmitError( |
| ('%s:%d: Use of DCHECK_IS_ON() must be written as "#if ' + |
| 'DCHECK_IS_ON()", not forgetting the parentheses.') |
| % (f.LocalPath(), lnum))) |
| return errors |
| |
| |
| def _FindHistogramNameInLine(histogram_name, line): |
| """Tries to find a histogram name or prefix in a line.""" |
| if not "affected-histogram" in line: |
| return histogram_name in line |
| # A histogram_suffixes tag type has an affected-histogram name as a prefix of |
| # the histogram_name. |
| if not '"' in line: |
| return False |
| histogram_prefix = line.split('\"')[1] |
| return histogram_prefix in histogram_name |
| |
| |
| def _CheckUmaHistogramChanges(input_api, output_api): |
| """Check that UMA histogram names in touched lines can still be found in other |
| lines of the patch or in histograms.xml. Note that this check would not catch |
| the reverse: changes in histograms.xml not matched in the code itself.""" |
| touched_histograms = [] |
| histograms_xml_modifications = [] |
| call_pattern_c = r'\bUMA_HISTOGRAM.*\(' |
| call_pattern_java = r'\bRecordHistogram\.record[a-zA-Z]+Histogram\(' |
| name_pattern = r'"(.*?)"' |
| single_line_c_re = input_api.re.compile(call_pattern_c + name_pattern) |
| single_line_java_re = input_api.re.compile(call_pattern_java + name_pattern) |
| split_line_c_prefix_re = input_api.re.compile(call_pattern_c) |
| split_line_java_prefix_re = input_api.re.compile(call_pattern_java) |
| split_line_suffix_re = input_api.re.compile(r'^\s*' + name_pattern) |
| last_line_matched_prefix = False |
| for f in input_api.AffectedFiles(): |
| # If histograms.xml itself is modified, keep the modified lines for later. |
| if f.LocalPath().endswith(('histograms.xml')): |
| histograms_xml_modifications = f.ChangedContents() |
| continue |
| if f.LocalPath().endswith(('cc', 'mm', 'cpp')): |
| single_line_re = single_line_c_re |
| split_line_prefix_re = split_line_c_prefix_re |
| elif f.LocalPath().endswith(('java')): |
| single_line_re = single_line_java_re |
| split_line_prefix_re = split_line_java_prefix_re |
| else: |
| continue |
| for line_num, line in f.ChangedContents(): |
| if last_line_matched_prefix: |
| suffix_found = split_line_suffix_re.search(line) |
| if suffix_found : |
| touched_histograms.append([suffix_found.group(1), f, line_num]) |
| last_line_matched_prefix = False |
| continue |
| found = single_line_re.search(line) |
| if found: |
| touched_histograms.append([found.group(1), f, line_num]) |
| continue |
| last_line_matched_prefix = split_line_prefix_re.search(line) |
| |
| # Search for the touched histogram names in the local modifications to |
| # histograms.xml, and, if not found, on the base histograms.xml file. |
| unmatched_histograms = [] |
| for histogram_info in touched_histograms: |
| histogram_name_found = False |
| for line_num, line in histograms_xml_modifications: |
| histogram_name_found = _FindHistogramNameInLine(histogram_info[0], line) |
| if histogram_name_found: |
| break |
| if not histogram_name_found: |
| unmatched_histograms.append(histogram_info) |
| |
| histograms_xml_path = 'tools/metrics/histograms/histograms.xml' |
| problems = [] |
| if unmatched_histograms: |
| with open(histograms_xml_path) as histograms_xml: |
| for histogram_name, f, line_num in unmatched_histograms: |
| histograms_xml.seek(0) |
| histogram_name_found = False |
| for line in histograms_xml: |
| histogram_name_found = _FindHistogramNameInLine(histogram_name, line) |
| if histogram_name_found: |
| break |
| if not histogram_name_found: |
| problems.append(' [%s:%d] %s' % |
| (f.LocalPath(), line_num, histogram_name)) |
| |
| if not problems: |
| return [] |
| return [output_api.PresubmitPromptWarning('Some UMA_HISTOGRAM lines have ' |
| 'been modified and the associated histogram name has no match in either ' |
| '%s or the modifications of it:' % (histograms_xml_path), problems)] |
| |
| |
| def _CheckFlakyTestUsage(input_api, output_api): |
| """Check that FlakyTest annotation is our own instead of the android one""" |
| pattern = input_api.re.compile(r'import android.test.FlakyTest;') |
| files = [] |
| for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile): |
| if f.LocalPath().endswith('Test.java'): |
| if pattern.search(input_api.ReadFile(f)): |
| files.append(f) |
| if len(files): |
| return [output_api.PresubmitError( |
| 'Use org.chromium.base.test.util.FlakyTest instead of ' |
| 'android.test.FlakyTest', |
| files)] |
| return [] |
| |
| |
| def _CheckNoNewWStrings(input_api, output_api): |
| """Checks to make sure we don't introduce use of wstrings.""" |
| problems = [] |
| for f in input_api.AffectedFiles(): |
| if (not f.LocalPath().endswith(('.cc', '.h')) or |
| f.LocalPath().endswith(('test.cc', '_win.cc', '_win.h')) or |
| '/win/' in f.LocalPath() or |
| 'chrome_elf' in f.LocalPath() or |
| 'install_static' in f.LocalPath()): |
| continue |
| |
| allowWString = False |
| for line_num, line in f.ChangedContents(): |
| if 'presubmit: allow wstring' in line: |
| allowWString = True |
| elif not allowWString and 'wstring' in line: |
| problems.append(' %s:%d' % (f.LocalPath(), line_num)) |
| allowWString = False |
| else: |
| allowWString = False |
| |
| if not problems: |
| return [] |
| return [output_api.PresubmitPromptWarning('New code should not use wstrings.' |
| ' If you are calling a cross-platform API that accepts a wstring, ' |
| 'fix the API.\n' + |
| '\n'.join(problems))] |
| |
| |
| def _CheckNoDEPSGIT(input_api, output_api): |
| """Make sure .DEPS.git is never modified manually.""" |
| if any(f.LocalPath().endswith('.DEPS.git') for f in |
| input_api.AffectedFiles()): |
| return [output_api.PresubmitError( |
| 'Never commit changes to .DEPS.git. This file is maintained by an\n' |
| 'automated system based on what\'s in DEPS and your changes will be\n' |
| 'overwritten.\n' |
| 'See https://sites.google.com/a/chromium.org/dev/developers/how-tos/' |
| 'get-the-code#Rolling_DEPS\n' |
| 'for more information')] |
| return [] |
| |
| |
| def _CheckValidHostsInDEPS(input_api, output_api): |
| """Checks that DEPS file deps are from allowed_hosts.""" |
| # Run only if DEPS file has been modified to annoy fewer bystanders. |
| if all(f.LocalPath() != 'DEPS' for f in input_api.AffectedFiles()): |
| return [] |
| # Outsource work to gclient verify |
| try: |
| input_api.subprocess.check_output(['gclient', 'verify'], |
| stderr=input_api.subprocess.STDOUT) |
| return [] |
| except input_api.subprocess.CalledProcessError as error: |
| return [output_api.PresubmitError( |
| 'DEPS file must have only git dependencies.', |
| long_text=error.output)] |
| |
| |
| def _CheckNoBannedFunctions(input_api, output_api): |
| """Make sure that banned functions are not used.""" |
| warnings = [] |
| errors = [] |
| |
| def IsBlacklisted(affected_file, blacklist): |
| local_path = affected_file.LocalPath() |
| for item in blacklist: |
| if input_api.re.match(item, local_path): |
| return True |
| return False |
| |
| def IsIosObcjFile(affected_file): |
| local_path = affected_file.LocalPath() |
| if input_api.os_path.splitext(local_path)[-1] not in ('.mm', '.m', '.h'): |
| return False |
| basename = input_api.os_path.basename(local_path) |
| if 'ios' in basename.split('_'): |
| return True |
| for sep in (input_api.os_path.sep, input_api.os_path.altsep): |
| if sep and 'ios' in local_path.split(sep): |
| return True |
| return False |
| |
| def CheckForMatch(affected_file, line_num, line, func_name, message, error): |
| matched = False |
| if func_name[0:1] == '/': |
| regex = func_name[1:] |
| if input_api.re.search(regex, line): |
| matched = True |
| elif func_name in line: |
| matched = True |
| if matched: |
| problems = warnings |
| if error: |
| problems = errors |
| problems.append(' %s:%d:' % (affected_file.LocalPath(), line_num)) |
| for message_line in message: |
| problems.append(' %s' % message_line) |
| |
| file_filter = lambda f: f.LocalPath().endswith(('.java')) |
| for f in input_api.AffectedFiles(file_filter=file_filter): |
| for line_num, line in f.ChangedContents(): |
| for func_name, message, error in _BANNED_JAVA_FUNCTIONS: |
| CheckForMatch(f, line_num, line, func_name, message, error) |
| |
| file_filter = lambda f: f.LocalPath().endswith(('.mm', '.m', '.h')) |
| for f in input_api.AffectedFiles(file_filter=file_filter): |
| for line_num, line in f.ChangedContents(): |
| for func_name, message, error in _BANNED_OBJC_FUNCTIONS: |
| CheckForMatch(f, line_num, line, func_name, message, error) |
| |
| for f in input_api.AffectedFiles(file_filter=IsIosObcjFile): |
| for line_num, line in f.ChangedContents(): |
| for func_name, message, error in _BANNED_IOS_OBJC_FUNCTIONS: |
| CheckForMatch(f, line_num, line, func_name, message, error) |
| |
| file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm', '.h')) |
| for f in input_api.AffectedFiles(file_filter=file_filter): |
| for line_num, line in f.ChangedContents(): |
| for func_name, message, error, excluded_paths in _BANNED_CPP_FUNCTIONS: |
| if IsBlacklisted(f, excluded_paths): |
| continue |
| CheckForMatch(f, line_num, line, func_name, message, error) |
| |
| result = [] |
| if (warnings): |
| result.append(output_api.PresubmitPromptWarning( |
| 'Banned functions were used.\n' + '\n'.join(warnings))) |
| if (errors): |
| result.append(output_api.PresubmitError( |
| 'Banned functions were used.\n' + '\n'.join(errors))) |
| return result |
| |
| |
| def _CheckNoPragmaOnce(input_api, output_api): |
| """Make sure that banned functions are not used.""" |
| files = [] |
| pattern = input_api.re.compile(r'^#pragma\s+once', |
| input_api.re.MULTILINE) |
| for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile): |
| if not f.LocalPath().endswith('.h'): |
| continue |
| contents = input_api.ReadFile(f) |
| if pattern.search(contents): |
| files.append(f) |
| |
| if files: |
| return [output_api.PresubmitError( |
| 'Do not use #pragma once in header files.\n' |
| 'See http://www.chromium.org/developers/coding-style#TOC-File-headers', |
| files)] |
| return [] |
| |
| |
| def _CheckNoTrinaryTrueFalse(input_api, output_api): |
| """Checks to make sure we don't introduce use of foo ? true : false.""" |
| problems = [] |
| pattern = input_api.re.compile(r'\?\s*(true|false)\s*:\s*(true|false)') |
| for f in input_api.AffectedFiles(): |
| if not f.LocalPath().endswith(('.cc', '.h', '.inl', '.m', '.mm')): |
| continue |
| |
| for line_num, line in f.ChangedContents(): |
| if pattern.match(line): |
| problems.append(' %s:%d' % (f.LocalPath(), line_num)) |
| |
| if not problems: |
| return [] |
| return [output_api.PresubmitPromptWarning( |
| 'Please consider avoiding the "? true : false" pattern if possible.\n' + |
| '\n'.join(problems))] |
| |
| |
| def _CheckUnwantedDependencies(input_api, output_api): |
| """Runs checkdeps on #include and import statements added in this |
| change. Breaking - rules is an error, breaking ! rules is a |
| warning. |
| """ |
| import sys |
| # We need to wait until we have an input_api object and use this |
| # roundabout construct to import checkdeps because this file is |
| # eval-ed and thus doesn't have __file__. |
| original_sys_path = sys.path |
| try: |
| sys.path = sys.path + [input_api.os_path.join( |
| input_api.PresubmitLocalPath(), 'buildtools', 'checkdeps')] |
| import checkdeps |
| from cpp_checker import CppChecker |
| from java_checker import JavaChecker |
| from proto_checker import ProtoChecker |
| from rules import Rule |
| finally: |
| # Restore sys.path to what it was before. |
| sys.path = original_sys_path |
| |
| added_includes = [] |
| added_imports = [] |
| added_java_imports = [] |
| for f in input_api.AffectedFiles(): |
| if CppChecker.IsCppFile(f.LocalPath()): |
| changed_lines = [line for _, line in f.ChangedContents()] |
| added_includes.append([f.AbsoluteLocalPath(), changed_lines]) |
| elif ProtoChecker.IsProtoFile(f.LocalPath()): |
| changed_lines = [line for _, line in f.ChangedContents()] |
| added_imports.append([f.AbsoluteLocalPath(), changed_lines]) |
| elif JavaChecker.IsJavaFile(f.LocalPath()): |
| changed_lines = [line for _, line in f.ChangedContents()] |
| added_java_imports.append([f.AbsoluteLocalPath(), changed_lines]) |
| |
| deps_checker = checkdeps.DepsChecker(input_api.PresubmitLocalPath()) |
| |
| error_descriptions = [] |
| warning_descriptions = [] |
| error_subjects = set() |
| warning_subjects = set() |
| for path, rule_type, rule_description in deps_checker.CheckAddedCppIncludes( |
| added_includes): |
| path = input_api.os_path.relpath(path, input_api.PresubmitLocalPath()) |
| description_with_path = '%s\n %s' % (path, rule_description) |
| if rule_type == Rule.DISALLOW: |
| error_descriptions.append(description_with_path) |
| error_subjects.add("#includes") |
| else: |
| warning_descriptions.append(description_with_path) |
| warning_subjects.add("#includes") |
| |
| for path, rule_type, rule_description in deps_checker.CheckAddedProtoImports( |
| added_imports): |
| path = input_api.os_path.relpath(path, input_api.PresubmitLocalPath()) |
| description_with_path = '%s\n %s' % (path, rule_description) |
| if rule_type == Rule.DISALLOW: |
| error_descriptions.append(description_with_path) |
| error_subjects.add("imports") |
| else: |
| warning_descriptions.append(description_with_path) |
| warning_subjects.add("imports") |
| |
| for path, rule_type, rule_description in deps_checker.CheckAddedJavaImports( |
| added_java_imports, _JAVA_MULTIPLE_DEFINITION_EXCLUDED_PATHS): |
| path = input_api.os_path.relpath(path, input_api.PresubmitLocalPath()) |
| description_with_path = '%s\n %s' % (path, rule_description) |
| if rule_type == Rule.DISALLOW: |
| error_descriptions.append(description_with_path) |
| error_subjects.add("imports") |
| else: |
| warning_descriptions.append(description_with_path) |
| warning_subjects.add("imports") |
| |
| results = [] |
| if error_descriptions: |
| results.append(output_api.PresubmitError( |
| 'You added one or more %s that violate checkdeps rules.' |
| % " and ".join(error_subjects), |
| error_descriptions)) |
| if warning_descriptions: |
| results.append(output_api.PresubmitPromptOrNotify( |
| 'You added one or more %s of files that are temporarily\n' |
| 'allowed but being removed. Can you avoid introducing the\n' |
| '%s? See relevant DEPS file(s) for details and contacts.' % |
| (" and ".join(warning_subjects), "/".join(warning_subjects)), |
| warning_descriptions)) |
| return results |
| |
| |
| def _CheckFilePermissions(input_api, output_api): |
| """Check that all files have their permissions properly set.""" |
| if input_api.platform == 'win32': |
| return [] |
| checkperms_tool = input_api.os_path.join( |
| input_api.PresubmitLocalPath(), |
| 'tools', 'checkperms', 'checkperms.py') |
| args = [input_api.python_executable, checkperms_tool, |
| '--root', input_api.change.RepositoryRoot()] |
| with input_api.CreateTemporaryFile() as file_list: |
| for f in input_api.AffectedFiles(): |
| # checkperms.py file/directory arguments must be relative to the |
| # repository. |
| file_list.write(f.LocalPath() + '\n') |
| file_list.close() |
| args += ['--file-list', file_list.name] |
| try: |
| input_api.subprocess.check_output(args) |
| return [] |
| except input_api.subprocess.CalledProcessError as error: |
| return [output_api.PresubmitError( |
| 'checkperms.py failed:', |
| long_text=error.output)] |
| |
| |
| def _CheckTeamTags(input_api, output_api): |
| """Checks that OWNERS files have consistent TEAM and COMPONENT tags.""" |
| checkteamtags_tool = input_api.os_path.join( |
| input_api.PresubmitLocalPath(), |
| 'tools', 'checkteamtags', 'checkteamtags.py') |
| args = [input_api.python_executable, checkteamtags_tool, |
| '--root', input_api.change.RepositoryRoot()] |
| files = [f.LocalPath() for f in input_api.AffectedFiles(include_deletes=False) |
| if input_api.os_path.basename(f.AbsoluteLocalPath()).upper() == |
| 'OWNERS'] |
| try: |
| if files: |
| input_api.subprocess.check_output(args + files) |
| return [] |
| except input_api.subprocess.CalledProcessError as error: |
| return [output_api.PresubmitError( |
| 'checkteamtags.py failed:', |
| long_text=error.output)] |
| |
| |
| def _CheckNoAuraWindowPropertyHInHeaders(input_api, output_api): |
| """Makes sure we don't include ui/aura/window_property.h |
| in header files. |
| """ |
| pattern = input_api.re.compile(r'^#include\s*"ui/aura/window_property.h"') |
| errors = [] |
| for f in input_api.AffectedFiles(): |
| if not f.LocalPath().endswith('.h'): |
| continue |
| for line_num, line in f.ChangedContents(): |
| if pattern.match(line): |
| errors.append(' %s:%d' % (f.LocalPath(), line_num)) |
| |
| results = [] |
| if errors: |
| results.append(output_api.PresubmitError( |
| 'Header files should not include ui/aura/window_property.h', errors)) |
| return results |
| |
| |
| def _CheckForVersionControlConflictsInFile(input_api, f): |
| pattern = input_api.re.compile('^(?:<<<<<<<|>>>>>>>) |^=======$') |
| errors = [] |
| for line_num, line in f.ChangedContents(): |
| if f.LocalPath().endswith(('.md', '.rst', '.txt')): |
| # First-level headers in markdown look a lot like version control |
| # conflict markers. http://daringfireball.net/projects/markdown/basics |
| continue |
| if pattern.match(line): |
| errors.append(' %s:%d %s' % (f.LocalPath(), line_num, line)) |
| return errors |
| |
| |
| def _CheckForVersionControlConflicts(input_api, output_api): |
| """Usually this is not intentional and will cause a compile failure.""" |
| errors = [] |
| for f in input_api.AffectedFiles(): |
| errors.extend(_CheckForVersionControlConflictsInFile(input_api, f)) |
| |
| results = [] |
| if errors: |
| results.append(output_api.PresubmitError( |
| 'Version control conflict markers found, please resolve.', errors)) |
| return results |
| |
| |
| def _CheckGoogleSupportAnswerUrl(input_api, output_api): |
| pattern = input_api.re.compile('support\.google\.com\/chrome.*/answer') |
| errors = [] |
| for f in input_api.AffectedFiles(): |
| for line_num, line in f.ChangedContents(): |
| if pattern.search(line): |
| errors.append(' %s:%d %s' % (f.LocalPath(), line_num, line)) |
| |
| results = [] |
| if errors: |
| results.append(output_api.PresubmitPromptWarning( |
| 'Found Google support URL addressed by answer number. Please replace ' |
| 'with a p= identifier instead. See crbug.com/679462\n', errors)) |
| return results |
| |
| |
| def _CheckHardcodedGoogleHostsInLowerLayers(input_api, output_api): |
| def FilterFile(affected_file): |
| """Filter function for use with input_api.AffectedSourceFiles, |
| below. This filters out everything except non-test files from |
| top-level directories that generally speaking should not hard-code |
| service URLs (e.g. src/android_webview/, src/content/ and others). |
| """ |
| return input_api.FilterSourceFile( |
| affected_file, |
| white_list=[r'^(android_webview|base|content|net)[\\/].*'], |
| black_list=(_EXCLUDED_PATHS + |
| _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST)) |
| |
| base_pattern = ('"[^"]*(google|googleapis|googlezip|googledrive|appspot)' |
| '\.(com|net)[^"]*"') |
| comment_pattern = input_api.re.compile('//.*%s' % base_pattern) |
| pattern = input_api.re.compile(base_pattern) |
| problems = [] # items are (filename, line_number, line) |
| for f in input_api.AffectedSourceFiles(FilterFile): |
| for line_num, line in f.ChangedContents(): |
| if not comment_pattern.search(line) and pattern.search(line): |
| problems.append((f.LocalPath(), line_num, line)) |
| |
| if problems: |
| return [output_api.PresubmitPromptOrNotify( |
| 'Most layers below src/chrome/ should not hardcode service URLs.\n' |
| 'Are you sure this is correct?', |
| [' %s:%d: %s' % ( |
| problem[0], problem[1], problem[2]) for problem in problems])] |
| else: |
| return [] |
| |
| |
| # TODO: add unit tests. |
| def _CheckNoAbbreviationInPngFileName(input_api, output_api): |
| """Makes sure there are no abbreviations in the name of PNG files. |
| The native_client_sdk directory is excluded because it has auto-generated PNG |
| files for documentation. |
| """ |
| errors = [] |
| white_list = [r'.*_[a-z]_.*\.png$|.*_[a-z]\.png$'] |
| black_list = [r'^native_client_sdk[\\/]'] |
| file_filter = lambda f: input_api.FilterSourceFile( |
| f, white_list=white_list, black_list=black_list) |
| for f in input_api.AffectedFiles(include_deletes=False, |
| file_filter=file_filter): |
| errors.append(' %s' % f.LocalPath()) |
| |
| results = [] |
| if errors: |
| results.append(output_api.PresubmitError( |
| 'The name of PNG files should not have abbreviations. \n' |
| 'Use _hover.png, _center.png, instead of _h.png, _c.png.\n' |
| 'Contact oshima@chromium.org if you have questions.', errors)) |
| return results |
| |
| |
| def _ExtractAddRulesFromParsedDeps(parsed_deps): |
| """Extract the rules that add dependencies from a parsed DEPS file. |
| |
| Args: |
| parsed_deps: the locals dictionary from evaluating the DEPS file.""" |
| add_rules = set() |
| add_rules.update([ |
| rule[1:] for rule in parsed_deps.get('include_rules', []) |
| if rule.startswith('+') or rule.startswith('!') |
| ]) |
| for _, rules in parsed_deps.get('specific_include_rules', |
| {}).iteritems(): |
| add_rules.update([ |
| rule[1:] for rule in rules |
| if rule.startswith('+') or rule.startswith('!') |
| ]) |
| return add_rules |
| |
| |
| def _ParseDeps(contents): |
| """Simple helper for parsing DEPS files.""" |
| # Stubs for handling special syntax in the root DEPS file. |
| class _VarImpl: |
| |
| def __init__(self, local_scope): |
| self._local_scope = local_scope |
| |
| def Lookup(self, var_name): |
| """Implements the Var syntax.""" |
| try: |
| return self._local_scope['vars'][var_name] |
| except KeyError: |
| raise Exception('Var is not defined: %s' % var_name) |
| |
| local_scope = {} |
| global_scope = { |
| 'Var': _VarImpl(local_scope).Lookup, |
| } |
| exec contents in global_scope, local_scope |
| return local_scope |
| |
| |
| def _CalculateAddedDeps(os_path, old_contents, new_contents): |
| """Helper method for _CheckAddedDepsHaveTargetApprovals. Returns |
| a set of DEPS entries that we should look up. |
| |
| For a directory (rather than a specific filename) we fake a path to |
| a specific filename by adding /DEPS. This is chosen as a file that |
| will seldom or never be subject to per-file include_rules. |
| """ |
| # We ignore deps entries on auto-generated directories. |
| AUTO_GENERATED_DIRS = ['grit', 'jni'] |
| |
| old_deps = _ExtractAddRulesFromParsedDeps(_ParseDeps(old_contents)) |
| new_deps = _ExtractAddRulesFromParsedDeps(_ParseDeps(new_contents)) |
| |
| added_deps = new_deps.difference(old_deps) |
| |
| results = set() |
| for added_dep in added_deps: |
| if added_dep.split('/')[0] in AUTO_GENERATED_DIRS: |
| continue |
| # Assume that a rule that ends in .h is a rule for a specific file. |
| if added_dep.endswith('.h'): |
| results.add(added_dep) |
| else: |
| results.add(os_path.join(added_dep, 'DEPS')) |
| return results |
| |
| |
| def _CheckAddedDepsHaveTargetApprovals(input_api, output_api): |
| """When a dependency prefixed with + is added to a DEPS file, we |
| want to make sure that the change is reviewed by an OWNER of the |
| target file or directory, to avoid layering violations from being |
| introduced. This check verifies that this happens. |
| """ |
| virtual_depended_on_files = set() |
| |
| file_filter = lambda f: not input_api.re.match( |
| r"^third_party[\\/]blink[\\/].*", f.LocalPath()) |
| for f in input_api.AffectedFiles(include_deletes=False, |
| file_filter=file_filter): |
| filename = input_api.os_path.basename(f.LocalPath()) |
| if filename == 'DEPS': |
| virtual_depended_on_files.update(_CalculateAddedDeps( |
| input_api.os_path, |
| '\n'.join(f.OldContents()), |
| '\n'.join(f.NewContents()))) |
| |
| if not virtual_depended_on_files: |
| return [] |
| |
| if input_api.is_committing: |
| if input_api.tbr: |
| return [output_api.PresubmitNotifyResult( |
| '--tbr was specified, skipping OWNERS check for DEPS additions')] |
| if input_api.dry_run: |
| return [output_api.PresubmitNotifyResult( |
| 'This is a dry run, skipping OWNERS check for DEPS additions')] |
| if not input_api.change.issue: |
| return [output_api.PresubmitError( |
| "DEPS approval by OWNERS check failed: this change has " |
| "no change number, so we can't check it for approvals.")] |
| output = output_api.PresubmitError |
| else: |
| output = output_api.PresubmitNotifyResult |
| |
| owners_db = input_api.owners_db |
| owner_email, reviewers = ( |
| input_api.canned_checks.GetCodereviewOwnerAndReviewers( |
| input_api, |
| owners_db.email_regexp, |
| approval_needed=input_api.is_committing)) |
| |
| owner_email = owner_email or input_api.change.author_email |
| |
| reviewers_plus_owner = set(reviewers) |
| if owner_email: |
| reviewers_plus_owner.add(owner_email) |
| missing_files = owners_db.files_not_covered_by(virtual_depended_on_files, |
| reviewers_plus_owner) |
| |
| # We strip the /DEPS part that was added by |
| # _FilesToCheckForIncomingDeps to fake a path to a file in a |
| # directory. |
| def StripDeps(path): |
| start_deps = path.rfind('/DEPS') |
| if start_deps != -1: |
| return path[:start_deps] |
| else: |
| return path |
| unapproved_dependencies = ["'+%s'," % StripDeps(path) |
| for path in missing_files] |
| |
| if unapproved_dependencies: |
| output_list = [ |
| output('You need LGTM from owners of depends-on paths in DEPS that were ' |
| 'modified in this CL:\n %s' % |
| '\n '.join(sorted(unapproved_dependencies)))] |
| suggested_owners = owners_db.reviewers_for(missing_files, owner_email) |
| output_list.append(output( |
| 'Suggested missing target path OWNERS:\n %s' % |
| '\n '.join(suggested_owners or []))) |
| return output_list |
| |
| return [] |
| |
| |
| # TODO: add unit tests. |
| def _CheckSpamLogging(input_api, output_api): |
| file_inclusion_pattern = [r'.+%s' % _IMPLEMENTATION_EXTENSIONS] |
| black_list = (_EXCLUDED_PATHS + |
| _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST + |
| (r"^base[\\/]logging\.h$", |
| r"^base[\\/]logging\.cc$", |
| r"^chrome[\\/]app[\\/]chrome_main_delegate\.cc$", |
| r"^chrome[\\/]browser[\\/]chrome_browser_main\.cc$", |
| r"^chrome[\\/]browser[\\/]ui[\\/]startup[\\/]" |
| r"startup_browser_creator\.cc$", |
| r"^chrome[\\/]browser[\\/]browser_switcher[\\/]bho[\\/].*", |
| r"^chrome[\\/]installer[\\/]setup[\\/].*", |
| r"^chrome[\\/]chrome_cleaner[\\/].*", |
| r"chrome[\\/]browser[\\/]diagnostics[\\/]" + |
| r"diagnostics_writer\.cc$", |
| r"^chrome_elf[\\/]dll_hash[\\/]dll_hash_main\.cc$", |
| r"^chromecast[\\/]", |
| r"^cloud_print[\\/]", |
| r"^components[\\/]browser_watcher[\\/]" |
| r"dump_stability_report_main_win.cc$", |
| r"^components[\\/]html_viewer[\\/]" |
| r"web_test_delegate_impl\.cc$", |
| r"^components[\\/]zucchini[\\/].*", |
| # TODO(peter): Remove this exception. https://crbug.com/534537 |
| r"^content[\\/]browser[\\/]notifications[\\/]" |
| r"notification_event_dispatcher_impl\.cc$", |
| r"^content[\\/]common[\\/]gpu[\\/]client[\\/]" |
| r"gl_helper_benchmark\.cc$", |
| r"^courgette[\\/]courgette_minimal_tool\.cc$", |
| r"^courgette[\\/]courgette_tool\.cc$", |
| r"^extensions[\\/]renderer[\\/]logging_native_handler\.cc$", |
| r"^fuchsia[\\/]engine[\\/]browser[\\/]frame_impl.cc$", |
| r"^headless[\\/]app[\\/]headless_shell\.cc$", |
| r"^ipc[\\/]ipc_logging\.cc$", |
| r"^native_client_sdk[\\/]", |
| r"^remoting[\\/]base[\\/]logging\.h$", |
| r"^remoting[\\/]host[\\/].*", |
| r"^sandbox[\\/]linux[\\/].*", |
| r"^storage[\\/]browser[\\/]fileapi[\\/]" + |
| r"dump_file_system.cc$", |
| r"^tools[\\/]", |
| r"^ui[\\/]base[\\/]resource[\\/]data_pack.cc$", |
| r"^ui[\\/]aura[\\/]bench[\\/]bench_main\.cc$", |
| r"^ui[\\/]ozone[\\/]platform[\\/]cast[\\/]")) |
| source_file_filter = lambda x: input_api.FilterSourceFile( |
| x, white_list=file_inclusion_pattern, black_list=black_list) |
| |
| log_info = set([]) |
| printf = set([]) |
| |
| for f in input_api.AffectedSourceFiles(source_file_filter): |
| for _, line in f.ChangedContents(): |
| if input_api.re.search(r"\bD?LOG\s*\(\s*INFO\s*\)", line): |
| log_info.add(f.LocalPath()) |
| elif input_api.re.search(r"\bD?LOG_IF\s*\(\s*INFO\s*,", line): |
| log_info.add(f.LocalPath()) |
| |
| if input_api.re.search(r"\bprintf\(", line): |
| printf.add(f.LocalPath()) |
| elif input_api.re.search(r"\bfprintf\((stdout|stderr)", line): |
| printf.add(f.LocalPath()) |
| |
| if log_info: |
| return [output_api.PresubmitError( |
| 'These files spam the console log with LOG(INFO):', |
| items=log_info)] |
| if printf: |
| return [output_api.PresubmitError( |
| 'These files spam the console log with printf/fprintf:', |
| items=printf)] |
| return [] |
| |
| |
| def _CheckForAnonymousVariables(input_api, output_api): |
| """These types are all expected to hold locks while in scope and |
| so should never be anonymous (which causes them to be immediately |
| destroyed).""" |
| they_who_must_be_named = [ |
| 'base::AutoLock', |
| 'base::AutoReset', |
| 'base::AutoUnlock', |
| 'SkAutoAlphaRestore', |
| 'SkAutoBitmapShaderInstall', |
| 'SkAutoBlitterChoose', |
| 'SkAutoBounderCommit', |
| 'SkAutoCallProc', |
| 'SkAutoCanvasRestore', |
| 'SkAutoCommentBlock', |
| 'SkAutoDescriptor', |
| 'SkAutoDisableDirectionCheck', |
| 'SkAutoDisableOvalCheck', |
| 'SkAutoFree', |
| 'SkAutoGlyphCache', |
| 'SkAutoHDC', |
| 'SkAutoLockColors', |
| 'SkAutoLockPixels', |
| 'SkAutoMalloc', |
| 'SkAutoMaskFreeImage', |
| 'SkAutoMutexAcquire', |
| 'SkAutoPathBoundsUpdate', |
| 'SkAutoPDFRelease', |
| 'SkAutoRasterClipValidate', |
| 'SkAutoRef', |
| 'SkAutoTime', |
| 'SkAutoTrace', |
| 'SkAutoUnref', |
| ] |
| anonymous = r'(%s)\s*[({]' % '|'.join(they_who_must_be_named) |
| # bad: base::AutoLock(lock.get()); |
| # not bad: base::AutoLock lock(lock.get()); |
| bad_pattern = input_api.re.compile(anonymous) |
| # good: new base::AutoLock(lock.get()) |
| good_pattern = input_api.re.compile(r'\bnew\s*' + anonymous) |
| errors = [] |
| |
| for f in input_api.AffectedFiles(): |
| if not f.LocalPath().endswith(('.cc', '.h', '.inl', '.m', '.mm')): |
| continue |
| for linenum, line in f.ChangedContents(): |
| if bad_pattern.search(line) and not good_pattern.search(line): |
| errors.append('%s:%d' % (f.LocalPath(), linenum)) |
| |
| if errors: |
| return [output_api.PresubmitError( |
| 'These lines create anonymous variables that need to be named:', |
| items=errors)] |
| return [] |
| |
| |
| def _CheckUniquePtr(input_api, output_api): |
| # Returns whether |template_str| is of the form <T, U...> for some types T |
| # and U. Assumes that |template_str| is already in the form <...>. |
| def HasMoreThanOneArg(template_str): |
| # Level of <...> nesting. |
| nesting = 0 |
| for c in template_str: |
| if c == '<': |
| nesting += 1 |
| elif c == '>': |
| nesting -= 1 |
| elif c == ',' and nesting == 1: |
| return True |
| return False |
| |
| file_inclusion_pattern = [r'.+%s' % _IMPLEMENTATION_EXTENSIONS] |
| sources = lambda affected_file: input_api.FilterSourceFile( |
| affected_file, |
| black_list=(_EXCLUDED_PATHS + _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST), |
| white_list=file_inclusion_pattern) |
| |
| # Pattern to capture a single "<...>" block of template arguments. It can |
| # handle linearly nested blocks, such as "<std::vector<std::set<T>>>", but |
| # cannot handle branching structures, such as "<pair<set<T>,set<U>>". The |
| # latter would likely require counting that < and > match, which is not |
| # expressible in regular languages. Should the need arise, one can introduce |
| # limited counting (matching up to a total number of nesting depth), which |
| # should cover all practical cases for already a low nesting limit. |
| template_arg_pattern = ( |
| r'<[^>]*' # Opening block of <. |
| r'>([^<]*>)?') # Closing block of >. |
| # Prefix expressing that whatever follows is not already inside a <...> |
| # block. |
| not_inside_template_arg_pattern = r'(^|[^<,\s]\s*)' |
| null_construct_pattern = input_api.re.compile( |
| not_inside_template_arg_pattern |
| + r'\bstd::unique_ptr' |
| + template_arg_pattern |
| + r'\(\)') |
| |
| # Same as template_arg_pattern, but excluding type arrays, e.g., <T[]>. |
| template_arg_no_array_pattern = ( |
| r'<[^>]*[^]]' # Opening block of <. |
| r'>([^(<]*[^]]>)?') # Closing block of >. |
| # Prefix saying that what follows is the start of an expression. |
| start_of_expr_pattern = r'(=|\breturn|^)\s*' |
| # Suffix saying that what follows are call parentheses with a non-empty list |
| # of arguments. |
| nonempty_arg_list_pattern = r'\(([^)]|$)' |
| # Put the template argument into a capture group for deeper examination later. |
| return_construct_pattern = input_api.re.compile( |
| start_of_expr_pattern |
| + r'std::unique_ptr' |
| + '(?P<template_arg>' |
| + template_arg_no_array_pattern |
| + ')' |
| + nonempty_arg_list_pattern) |
| |
| problems_constructor = [] |
| problems_nullptr = [] |
| for f in input_api.AffectedSourceFiles(sources): |
| for line_number, line in f.ChangedContents(): |
| # Disallow: |
| # return std::unique_ptr<T>(foo); |
| # bar = std::unique_ptr<T>(foo); |
| # But allow: |
| # return std::unique_ptr<T[]>(foo); |
| # bar = std::unique_ptr<T[]>(foo); |
| # And also allow cases when the second template argument is present. Those |
| # cases cannot be handled by std::make_unique: |
| # return std::unique_ptr<T, U>(foo); |
| # bar = std::unique_ptr<T, U>(foo); |
| local_path = f.LocalPath() |
| return_construct_result = return_construct_pattern.search(line) |
| if return_construct_result and not HasMoreThanOneArg( |
| return_construct_result.group('template_arg')): |
| problems_constructor.append( |
| '%s:%d\n %s' % (local_path, line_number, line.strip())) |
| # Disallow: |
| # std::unique_ptr<T>() |
| if null_construct_pattern.search(line): |
| problems_nullptr.append( |
| '%s:%d\n %s' % (local_path, line_number, line.strip())) |
| |
| errors = [] |
| if problems_nullptr: |
| errors.append(output_api.PresubmitError( |
| 'The following files use std::unique_ptr<T>(). Use nullptr instead.', |
| problems_nullptr)) |
| if problems_constructor: |
| errors.append(output_api.PresubmitError( |
| 'The following files use explicit std::unique_ptr constructor.' |
| 'Use std::make_unique<T>() instead.', |
| problems_constructor)) |
| return errors |
| |
| |
| def _CheckUserActionUpdate(input_api, output_api): |
| """Checks if any new user action has been added.""" |
| if any('actions.xml' == input_api.os_path.basename(f) for f in |
| input_api.LocalPaths()): |
| # If actions.xml is already included in the changelist, the PRESUBMIT |
| # for actions.xml will do a more complete presubmit check. |
| return [] |
| |
| file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm')) |
| action_re = r'[^a-zA-Z]UserMetricsAction\("([^"]*)' |
| current_actions = None |
| for f in input_api.AffectedFiles(file_filter=file_filter): |
| for line_num, line in f.ChangedContents(): |
| match = input_api.re.search(action_re, line) |
| if match: |
| # Loads contents in tools/metrics/actions/actions.xml to memory. It's |
| # loaded only once. |
| if not current_actions: |
| with open('tools/metrics/actions/actions.xml') as actions_f: |
| current_actions = actions_f.read() |
| # Search for the matched user action name in |current_actions|. |
| for action_name in match.groups(): |
| action = 'name="{0}"'.format(action_name) |
| if action not in current_actions: |
| return [output_api.PresubmitPromptWarning( |
| 'File %s line %d: %s is missing in ' |
| 'tools/metrics/actions/actions.xml. Please run ' |
| 'tools/metrics/actions/extract_actions.py to update.' |
| % (f.LocalPath(), line_num, action_name))] |
| return [] |
| |
| |
| def _ImportJSONCommentEater(input_api): |
| import sys |
| sys.path = sys.path + [input_api.os_path.join( |
| input_api.PresubmitLocalPath(), |
| 'tools', 'json_comment_eater')] |
| import json_comment_eater |
| return json_comment_eater |
| |
| |
| def _GetJSONParseError(input_api, filename, eat_comments=True): |
| try: |
| contents = input_api.ReadFile(filename) |
| if eat_comments: |
| json_comment_eater = _ImportJSONCommentEater(input_api) |
| contents = json_comment_eater.Nom(contents) |
| |
| input_api.json.loads(contents) |
| except ValueError as e: |
| return e |
| return None |
| |
| |
| def _GetIDLParseError(input_api, filename): |
| try: |
| contents = input_api.ReadFile(filename) |
| idl_schema = input_api.os_path.join( |
| input_api.PresubmitLocalPath(), |
| 'tools', 'json_schema_compiler', 'idl_schema.py') |
| process = input_api.subprocess.Popen( |
| [input_api.python_executable, idl_schema], |
| stdin=input_api.subprocess.PIPE, |
| stdout=input_api.subprocess.PIPE, |
| stderr=input_api.subprocess.PIPE, |
| universal_newlines=True) |
| (_, error) = process.communicate(input=contents) |
| return error or None |
| except ValueError as e: |
| return e |
| |
| |
| def _CheckParseErrors(input_api, output_api): |
| """Check that IDL and JSON files do not contain syntax errors.""" |
| actions = { |
| '.idl': _GetIDLParseError, |
| '.json': _GetJSONParseError, |
| } |
| # Most JSON files are preprocessed and support comments, but these do not. |
| json_no_comments_patterns = [ |
| r'^testing[\\/]', |
| ] |
| # Only run IDL checker on files in these directories. |
| idl_included_patterns = [ |
| r'^chrome[\\/]common[\\/]extensions[\\/]api[\\/]', |
| r'^extensions[\\/]common[\\/]api[\\/]', |
| ] |
| |
| def get_action(affected_file): |
| filename = affected_file.LocalPath() |
| return actions.get(input_api.os_path.splitext(filename)[1]) |
| |
| def FilterFile(affected_file): |
| action = get_action(affected_file) |
| if not action: |
| return False |
| path = affected_file.LocalPath() |
| |
| if _MatchesFile(input_api, _KNOWN_INVALID_JSON_FILE_PATTERNS, path): |
| return False |
| |
| if (action == _GetIDLParseError and |
| not _MatchesFile(input_api, idl_included_patterns, path)): |
| return False |
| return True |
| |
| results = [] |
| for affected_file in input_api.AffectedFiles( |
| file_filter=FilterFile, include_deletes=False): |
| action = get_action(affected_file) |
| kwargs = {} |
| if (action == _GetJSONParseError and |
| _MatchesFile(input_api, json_no_comments_patterns, |
| affected_file.LocalPath())): |
| kwargs['eat_comments'] = False |
| parse_error = action(input_api, |
| affected_file.AbsoluteLocalPath(), |
| **kwargs) |
| if parse_error: |
| results.append(output_api.PresubmitError('%s could not be parsed: %s' % |
| (affected_file.LocalPath(), parse_error))) |
| return results |
| |
| |
| def _CheckJavaStyle(input_api, output_api): |
| """Runs checkstyle on changed java files and returns errors if any exist.""" |
| import sys |
| original_sys_path = sys.path |
| try: |
| sys.path = sys.path + [input_api.os_path.join( |
| input_api.PresubmitLocalPath(), 'tools', 'android', 'checkstyle')] |
| import checkstyle |
| finally: |
| # Restore sys.path to what it was before. |
| sys.path = original_sys_path |
| |
| return checkstyle.RunCheckstyle( |
| input_api, output_api, 'tools/android/checkstyle/chromium-style-5.0.xml', |
| black_list=_EXCLUDED_PATHS + input_api.DEFAULT_BLACK_LIST) |
| |
| |
| def _MatchesFile(input_api, patterns, path): |
| for pattern in patterns: |
| if input_api.re.search(pattern, path): |
| return True |
| return False |
| |
| |
| def _GetOwnersFilesToCheckForIpcOwners(input_api): |
| """Gets a list of OWNERS files to check for correct security owners. |
| |
| Returns: |
| A dictionary mapping an OWNER file to the list of OWNERS rules it must |
| contain to cover IPC-related files with noparent reviewer rules. |
| """ |
| # Whether or not a file affects IPC is (mostly) determined by a simple list |
| # of filename patterns. |
| file_patterns = [ |
| # Legacy IPC: |
| '*_messages.cc', |
| '*_messages*.h', |
| '*_param_traits*.*', |
| # Mojo IPC: |
| '*.mojom', |
| '*_mojom_traits*.*', |
| '*_struct_traits*.*', |
| '*_type_converter*.*', |
| '*.typemap', |
| # Android native IPC: |
| '*.aidl', |
| # Blink uses a different file naming convention: |
| '*EnumTraits*.*', |
| "*MojomTraits*.*", |
| '*StructTraits*.*', |
| '*TypeConverter*.*', |
| ] |
| |
| # These third_party directories do not contain IPCs, but contain files |
| # matching the above patterns, which trigger false positives. |
| exclude_paths = [ |
| 'third_party/crashpad/*', |
| 'third_party/protobuf/benchmarks/python/*', |
| 'third_party/third_party/blink/renderer/platform/bindings/*', |
| 'third_party/win_build_output/*', |
| ] |
| |
| # Dictionary mapping an OWNERS file path to Patterns. |
| # Patterns is a dictionary mapping glob patterns (suitable for use in per-file |
| # rules ) to a PatternEntry. |
| # PatternEntry is a dictionary with two keys: |
| # - 'files': the files that are matched by this pattern |
| # - 'rules': the per-file rules needed for this pattern |
| # For example, if we expect OWNERS file to contain rules for *.mojom and |
| # *_struct_traits*.*, Patterns might look like this: |
| # { |
| # '*.mojom': { |
| # 'files': ..., |
| # 'rules': [ |
| # 'per-file *.mojom=set noparent', |
| # 'per-file *.mojom=file://ipc/SECURITY_OWNERS', |
| # ], |
| # }, |
| # '*_struct_traits*.*': { |
| # 'files': ..., |
| # 'rules': [ |
| # 'per-file *_struct_traits*.*=set noparent', |
| # 'per-file *_struct_traits*.*=file://ipc/SECURITY_OWNERS', |
| # ], |
| # }, |
| # } |
| to_check = {} |
| |
| def AddPatternToCheck(input_file, pattern): |
| owners_file = input_api.os_path.join( |
| input_api.os_path.dirname(input_file.LocalPath()), 'OWNERS') |
| if owners_file not in to_check: |
| to_check[owners_file] = {} |
| if pattern not in to_check[owners_file]: |
| to_check[owners_file][pattern] = { |
| 'files': [], |
| 'rules': [ |
| 'per-file %s=set noparent' % pattern, |
| 'per-file %s=file://ipc/SECURITY_OWNERS' % pattern, |
| ] |
| } |
| to_check[owners_file][pattern]['files'].append(input_file) |
| |
| # Iterate through the affected files to see what we actually need to check |
| # for. We should only nag patch authors about per-file rules if a file in that |
| # directory would match that pattern. If a directory only contains *.mojom |
| # files and no *_messages*.h files, we should only nag about rules for |
| # *.mojom files. |
| for f in input_api.AffectedFiles(include_deletes=False): |
| # Manifest files don't have a strong naming convention. Instead, scan |
| # affected files for .json, .cc, and .h files which look like they contain |
| # a manifest definition. |
| if (f.LocalPath().endswith('.json') and |
| not _MatchesFile(input_api, _KNOWN_INVALID_JSON_FILE_PATTERNS, |
| f.LocalPath())): |
| json_comment_eater = _ImportJSONCommentEater(input_api) |
| mostly_json_lines = '\n'.join(f.NewContents()) |
| # Comments aren't allowed in strict JSON, so filter them out. |
| json_lines = json_comment_eater.Nom(mostly_json_lines) |
| try: |
| json_content = input_api.json.loads(json_lines) |
| except: |
| # There's another PRESUBMIT check that already verifies that JSON files |
| # are not invalid, so no need to emit another warning here. |
| continue |
| if 'interface_provider_specs' in json_content: |
| AddPatternToCheck(f, input_api.os_path.basename(f.LocalPath())) |
| else: |
| manifest_pattern = input_api.re.compile('manifests?\.(cc|h)$') |
| test_manifest_pattern = input_api.re.compile('test_manifests?\.(cc|h)') |
| if (manifest_pattern.search(f.LocalPath()) and not |
| test_manifest_pattern.search(f.LocalPath())): |
| # We expect all actual service manifest files to contain at least one |
| # qualified reference to service_manager::Manifest. |
| if 'service_manager::Manifest' in '\n'.join(f.NewContents()): |
| AddPatternToCheck(f, input_api.os_path.basename(f.LocalPath())) |
| for pattern in file_patterns: |
| if input_api.fnmatch.fnmatch( |
| input_api.os_path.basename(f.LocalPath()), pattern): |
| skip = False |
| for exclude in exclude_paths: |
| if input_api.fnmatch.fnmatch(f.LocalPath(), exclude): |
| skip = True |
| break |
| if skip: |
| continue |
| AddPatternToCheck(f, pattern) |
| break |
| |
| return to_check |
| |
| |
| def _CheckIpcOwners(input_api, output_api): |
| """Checks that affected files involving IPC have an IPC OWNERS rule.""" |
| to_check = _GetOwnersFilesToCheckForIpcOwners(input_api) |
| |
| if to_check: |
| # If there are any OWNERS files to check, there are IPC-related changes in |
| # this CL. Auto-CC the review list. |
| output_api.AppendCC('ipc-security-reviews@chromium.org') |
| |
| # Go through the OWNERS files to check, filtering out rules that are already |
| # present in that OWNERS file. |
| for owners_file, patterns in to_check.iteritems(): |
| try: |
| with file(owners_file) as f: |
| lines = set(f.read().splitlines()) |
| for entry in patterns.itervalues(): |
| entry['rules'] = [rule for rule in entry['rules'] if rule not in lines |
| ] |
| except IOError: |
| # No OWNERS file, so all the rules are definitely missing. |
| continue |
| |
| # All the remaining lines weren't found in OWNERS files, so emit an error. |
| errors = [] |
| for owners_file, patterns in to_check.iteritems(): |
| missing_lines = [] |
| files = [] |
| for _, entry in patterns.iteritems(): |
| missing_lines.extend(entry['rules']) |
| files.extend([' %s' % f.LocalPath() for f in entry['files']]) |
| if missing_lines: |
| errors.append( |
| 'Because of the presence of files:\n%s\n\n' |
| '%s needs the following %d lines added:\n\n%s' % |
| ('\n'.join(files), owners_file, len(missing_lines), |
| '\n'.join(missing_lines))) |
| |
| results = [] |
| if errors: |
| if input_api.is_committing: |
| output = output_api.PresubmitError |
| else: |
| output = output_api.PresubmitPromptWarning |
| results.append(output( |
| 'Found OWNERS files that need to be updated for IPC security ' + |
| 'review coverage.\nPlease update the OWNERS files below:', |
| long_text='\n\n'.join(errors))) |
| |
| return results |
| |
| |
| def _CheckUselessForwardDeclarations(input_api, output_api): |
| """Checks that added or removed lines in non third party affected |
| header files do not lead to new useless class or struct forward |
| declaration. |
| """ |
| results = [] |
| class_pattern = input_api.re.compile(r'^class\s+(\w+);$', |
| input_api.re.MULTILINE) |
| struct_pattern = input_api.re.compile(r'^struct\s+(\w+);$', |
| input_api.re.MULTILINE) |
| for f in input_api.AffectedFiles(include_deletes=False): |
| if (f.LocalPath().startswith('third_party') and |
| not f.LocalPath().startswith('third_party/blink') and |
| not f.LocalPath().startswith('third_party\\blink')): |
| continue |
| |
| if not f.LocalPath().endswith('.h'): |
| continue |
| |
| contents = input_api.ReadFile(f) |
| fwd_decls = input_api.re.findall(class_pattern, contents) |
| fwd_decls.extend(input_api.re.findall(struct_pattern, contents)) |
| |
| useless_fwd_decls = [] |
| for decl in fwd_decls: |
| count = sum(1 for _ in input_api.re.finditer( |
| r'\b%s\b' % input_api.re.escape(decl), contents)) |
| if count == 1: |
| useless_fwd_decls.append(decl) |
| |
| if not useless_fwd_decls: |
| continue |
| |
| for line in f.GenerateScmDiff().splitlines(): |
| if (line.startswith('-') and not line.startswith('--') or |
| line.startswith('+') and not line.startswith('++')): |
| for decl in useless_fwd_decls: |
| if input_api.re.search(r'\b%s\b' % decl, line[1:]): |
| results.append(output_api.PresubmitPromptWarning( |
| '%s: %s forward declaration is no longer needed' % |
| (f.LocalPath(), decl))) |
| useless_fwd_decls.remove(decl) |
| |
| return results |
| |
| def _CheckAndroidDebuggableBuild(input_api, output_api): |
| """Checks that code uses BuildInfo.isDebugAndroid() instead of |
| Build.TYPE.equals('') or ''.equals(Build.TYPE) to check if |
| this is a debuggable build of Android. |
| """ |
| build_type_check_pattern = input_api.re.compile( |
| r'\bBuild\.TYPE\.equals\(|\.equals\(\s*\bBuild\.TYPE\)') |
| |
| errors = [] |
| |
| sources = lambda affected_file: input_api.FilterSourceFile( |
| affected_file, |
| black_list=(_EXCLUDED_PATHS + |
| _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST + |
| (r"^android_webview[\\/]support_library[\\/]" |
| "boundary_interfaces[\\/]", |
| r"^chrome[\\/]android[\\/]webapk[\\/].*", |
| r'^third_party[\\/].*', |
| r"tools[\\/]android[\\/]customtabs_benchmark[\\/].*", |
| r"webview[\\/]chromium[\\/]License.*",)), |
| white_list=[r'.*\.java$']) |
| |
| for f in input_api.AffectedSourceFiles(sources): |
| for line_num, line in f.ChangedContents(): |
| if build_type_check_pattern.search(line): |
| errors.append("%s:%d" % (f.LocalPath(), line_num)) |
| |
| results = [] |
| |
| if errors: |
| results.append(output_api.PresubmitPromptWarning( |
| 'Build.TYPE.equals or .equals(Build.TYPE) usage is detected.' |
| ' Please use BuildInfo.isDebugAndroid() instead.', |
| errors)) |
| |
| return results |
| |
| # TODO: add unit tests |
| def _CheckAndroidToastUsage(input_api, output_api): |
| """Checks that code uses org.chromium.ui.widget.Toast instead of |
| android.widget.Toast (Chromium Toast doesn't force hardware |
| acceleration on low-end devices, saving memory). |
| """ |
| toast_import_pattern = input_api.re.compile( |
| r'^import android\.widget\.Toast;$') |
| |
| errors = [] |
| |
| sources = lambda affected_file: input_api.FilterSourceFile( |
| affected_file, |
| black_list=(_EXCLUDED_PATHS + |
| _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST + |
| (r'^chromecast[\\/].*', |
| r'^remoting[\\/].*')), |
| white_list=[r'.*\.java$']) |
| |
| for f in input_api.AffectedSourceFiles(sources): |
| for line_num, line in f.ChangedContents(): |
| if toast_import_pattern.search(line): |
| errors.append("%s:%d" % (f.LocalPath(), line_num)) |
| |
| results = [] |
| |
| if errors: |
| results.append(output_api.PresubmitError( |
| 'android.widget.Toast usage is detected. Android toasts use hardware' |
| ' acceleration, and can be\ncostly on low-end devices. Please use' |
| ' org.chromium.ui.widget.Toast instead.\n' |
| 'Contact dskiba@chromium.org if you have any questions.', |
| errors)) |
| |
| return results |
| |
| |
| def _CheckAndroidCrLogUsage(input_api, output_api): |
| """Checks that new logs using org.chromium.base.Log: |
| - Are using 'TAG' as variable name for the tags (warn) |
| - Are using a tag that is shorter than 20 characters (error) |
| """ |
| |
| # Do not check format of logs in the given files |
| cr_log_check_excluded_paths = [ |
| # //chrome/android/webapk cannot depend on //base |
| r"^chrome[\\/]android[\\/]webapk[\\/].*", |
| # WebView license viewer code cannot depend on //base; used in stub APK. |
| r"^android_webview[\\/]glue[\\/]java[\\/]src[\\/]com[\\/]android[\\/]" |
| r"webview[\\/]chromium[\\/]License.*", |
| # The customtabs_benchmark is a small app that does not depend on Chromium |
| # java pieces. |
| r"tools[\\/]android[\\/]customtabs_benchmark[\\/].*", |
| ] |
| |
| cr_log_import_pattern = input_api.re.compile( |
| r'^import org\.chromium\.base\.Log;$', input_api.re.MULTILINE) |
| class_in_base_pattern = input_api.re.compile( |
| r'^package org\.chromium\.base;$', input_api.re.MULTILINE) |
| has_some_log_import_pattern = input_api.re.compile( |
| r'^import .*\.Log;$', input_api.re.MULTILINE) |
| # Extract the tag from lines like `Log.d(TAG, "*");` or `Log.d("TAG", "*");` |
| log_call_pattern = input_api.re.compile(r'^\s*Log\.\w\((?P<tag>\"?\w+\"?)\,') |
| log_decl_pattern = input_api.re.compile( |
| r'^\s*private static final String TAG = "(?P<name>(.*))";', |
| input_api.re.MULTILINE) |
| |
| REF_MSG = ('See docs/android_logging.md ' |
| 'or contact dgn@chromium.org for more info.') |
| sources = lambda x: input_api.FilterSourceFile(x, white_list=[r'.*\.java$'], |
| black_list=cr_log_check_excluded_paths) |
| |
| tag_decl_errors = [] |
| tag_length_errors = [] |
| tag_errors = [] |
| tag_with_dot_errors = [] |
| util_log_errors = [] |
| |
| for f in input_api.AffectedSourceFiles(sources): |
| file_content = input_api.ReadFile(f) |
| has_modified_logs = False |
| |
| # Per line checks |
| if (cr_log_import_pattern.search(file_content) or |
| (class_in_base_pattern.search(file_content) and |
| not has_some_log_import_pattern.search(file_content))): |
| # Checks to run for files using cr log |
| for line_num, line in f.ChangedContents(): |
| |
| # Check if the new line is doing some logging |
| match = log_call_pattern.search(line) |
| if match: |
| has_modified_logs = True |
| |
| # Make sure it uses "TAG" |
| if not match.group('tag') == 'TAG': |
| tag_errors.append("%s:%d" % (f.LocalPath(), line_num)) |
| else: |
| # Report non cr Log function calls in changed lines |
| for line_num, line in f.ChangedContents(): |
| if log_call_pattern.search(line): |
| util_log_errors.append("%s:%d" % (f.LocalPath(), line_num)) |
| |
| # Per file checks |
| if has_modified_logs: |
| # Make sure the tag is using the "cr" prefix and is not too long |
| match = log_decl_pattern.search(file_content) |
| tag_name = match.group('name') if match else None |
| if not tag_name: |
| tag_decl_errors.append(f.LocalPath()) |
| elif len(tag_name) > 20: |
| tag_length_errors.append(f.LocalPath()) |
| elif '.' in tag_name: |
| tag_with_dot_errors.append(f.LocalPath()) |
| |
| results = [] |
| if tag_decl_errors: |
| results.append(output_api.PresubmitPromptWarning( |
| 'Please define your tags using the suggested format: .\n' |
| '"private static final String TAG = "<package tag>".\n' |
| 'They will be prepended with "cr_" automatically.\n' + REF_MSG, |
| tag_decl_errors)) |
| |
| if tag_length_errors: |
| results.append(output_api.PresubmitError( |
| 'The tag length is restricted by the system to be at most ' |
| '20 characters.\n' + REF_MSG, |
| tag_length_errors)) |
| |
| if tag_errors: |
| results.append(output_api.PresubmitPromptWarning( |
| 'Please use a variable named "TAG" for your log tags.\n' + REF_MSG, |
| tag_errors)) |
| |
| if util_log_errors: |
| results.append(output_api.PresubmitPromptWarning( |
| 'Please use org.chromium.base.Log for new logs.\n' + REF_MSG, |
| util_log_errors)) |
| |
| if tag_with_dot_errors: |
| results.append(output_api.PresubmitPromptWarning( |
| 'Dot in log tags cause them to be elided in crash reports.\n' + REF_MSG, |
| tag_with_dot_errors)) |
| |
| return results |
| |
| |
| def _CheckAndroidTestJUnitFrameworkImport(input_api, output_api): |
| """Checks that junit.framework.* is no longer used.""" |
| deprecated_junit_framework_pattern = input_api.re.compile( |
| r'^import junit\.framework\..*;', |
| input_api.re.MULTILINE) |
| sources = lambda x: input_api.FilterSourceFile( |
| x, white_list=[r'.*\.java$'], black_list=None) |
| errors = [] |
| for f in input_api.AffectedFiles(sources): |
| for line_num, line in f.ChangedContents(): |
| if deprecated_junit_framework_pattern.search(line): |
| errors.append("%s:%d" % (f.LocalPath(), line_num)) |
| |
| results = [] |
| if errors: |
| results.append(output_api.PresubmitError( |
| 'APIs from junit.framework.* are deprecated, please use JUnit4 framework' |
| '(org.junit.*) from //third_party/junit. Contact yolandyan@chromium.org' |
| ' if you have any question.', errors)) |
| return results |
| |
| |
| def _CheckAndroidTestJUnitInheritance(input_api, output_api): |
| """Checks that if new Java test classes have inheritance. |
| Either the new test class is JUnit3 test or it is a JUnit4 test class |
| with a base class, either case is undesirable. |
| """ |
| class_declaration_pattern = input_api.re.compile(r'^public class \w*Test ') |
| |
| sources = lambda x: input_api.FilterSourceFile( |
| x, white_list=[r'.*Test\.java$'], black_list=None) |
| errors = [] |
| for f in input_api.AffectedFiles(sources): |
| if not f.OldContents(): |
| class_declaration_start_flag = False |
| for line_num, line in f.ChangedContents(): |
| if class_declaration_pattern.search(line): |
| class_declaration_start_flag = True |
| if class_declaration_start_flag and ' extends ' in line: |
| errors.append('%s:%d' % (f.LocalPath(), line_num)) |
| if '{' in line: |
| class_declaration_start_flag = False |
| |
| results = [] |
| if errors: |
| results.append(output_api.PresubmitPromptWarning( |
| 'The newly created files include Test classes that inherits from base' |
| ' class. Please do not use inheritance in JUnit4 tests or add new' |
| ' JUnit3 tests. Contact yolandyan@chromium.org if you have any' |
| ' questions.', errors)) |
| return results |
| |
| |
| def _CheckAndroidTestAnnotationUsage(input_api, output_api): |
| """Checks that android.test.suitebuilder.annotation.* is no longer used.""" |
| deprecated_annotation_import_pattern = input_api.re.compile( |
| r'^import android\.test\.suitebuilder\.annotation\..*;', |
| input_api.re.MULTILINE) |
| sources = lambda x: input_api.FilterSourceFile( |
| x, white_list=[r'.*\.java$'], black_list=None) |
| errors = [] |
| for f in input_api.AffectedFiles(sources): |
| for line_num, line in f.ChangedContents(): |
| if deprecated_annotation_import_pattern.search(line): |
| errors.append("%s:%d" % (f.LocalPath(), line_num)) |
| |
| results = [] |
| if errors: |
| results.append(output_api.PresubmitError( |
| 'Annotations in android.test.suitebuilder.annotation have been' |
| ' deprecated since API level 24. Please use android.support.test.filters' |
| ' from //third_party/android_support_test_runner:runner_java instead.' |
| ' Contact yolandyan@chromium.org if you have any questions.', errors)) |
| return results |
| |
| |
| def _CheckAndroidNewMdpiAssetLocation(input_api, output_api): |
| """Checks if MDPI assets are placed in a correct directory.""" |
| file_filter = lambda f: (f.LocalPath().endswith('.png') and |
| ('/res/drawable/' in f.LocalPath() or |
| '/res/drawable-ldrtl/' in f.LocalPath())) |
| errors = [] |
| for f in input_api.AffectedFiles(include_deletes=False, |
| file_filter=file_filter): |
| errors.append(' %s' % f.LocalPath()) |
| |
| results = [] |
| if errors: |
| results.append(output_api.PresubmitError( |
| 'MDPI assets should be placed in /res/drawable-mdpi/ or ' |
| '/res/drawable-ldrtl-mdpi/\ninstead of /res/drawable/ and' |
| '/res/drawable-ldrtl/.\n' |
| 'Contact newt@chromium.org if you have questions.', errors)) |
| return results |
| |
| |
| def _CheckAndroidWebkitImports(input_api, output_api): |
| """Checks that code uses org.chromium.base.Callback instead of |
| android.widget.ValueCallback except in the WebView glue layer. |
| """ |
| valuecallback_import_pattern = input_api.re.compile( |
| r'^import android\.webkit\.ValueCallback;$') |
| |
| errors = [] |
| |
| sources = lambda affected_file: input_api.FilterSourceFile( |
| affected_file, |
| black_list=(_EXCLUDED_PATHS + |
| _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST + |
| (r'^android_webview[\\/]glue[\\/].*',)), |
| white_list=[r'.*\.java$']) |
| |
| for f in input_api.AffectedSourceFiles(sources): |
| for line_num, line in f.ChangedContents(): |
| if valuecallback_import_pattern.search(line): |
| errors.append("%s:%d" % (f.LocalPath(), line_num)) |
| |
| results = [] |
| |
| if errors: |
| results.append(output_api.PresubmitError( |
| 'android.webkit.ValueCallback usage is detected outside of the glue' |
| ' layer. To stay compatible with the support library, android.webkit.*' |
| ' classes should only be used inside the glue layer and' |
| ' org.chromium.base.Callback should be used instead.', |
| errors)) |
| |
| return results |
| |
| |
| def _CheckAndroidXmlStyle(input_api, output_api, is_check_on_upload): |
| """Checks Android XML styles """ |
| import sys |
| original_sys_path = sys.path |
| try: |
| sys.path = sys.path + [input_api.os_path.join( |
| input_api.PresubmitLocalPath(), 'tools', 'android', 'checkxmlstyle')] |
| import checkxmlstyle |
| finally: |
| # Restore sys.path to what it was before. |
| sys.path = original_sys_path |
| |
| if is_check_on_upload: |
| return checkxmlstyle.CheckStyleOnUpload(input_api, output_api) |
| else: |
| return checkxmlstyle.CheckStyleOnCommit(input_api, output_api) |
| |
| |
| class PydepsChecker(object): |
| def __init__(self, input_api, pydeps_files): |
| self._file_cache = {} |
| self._input_api = input_api |
| self._pydeps_files = pydeps_files |
| |
| def _LoadFile(self, path): |
| """Returns the list of paths within a .pydeps file relative to //.""" |
| if path not in self._file_cache: |
| with open(path) as f: |
| self._file_cache[path] = f.read() |
| return self._file_cache[path] |
| |
| def _ComputeNormalizedPydepsEntries(self, pydeps_path): |
| """Returns an interable of paths within the .pydep, relativized to //.""" |
| os_path = self._input_api.os_path |
| pydeps_dir = os_path.dirname(pydeps_path) |
| entries = (l.rstrip() for l in self._LoadFile(pydeps_path).splitlines() |
| if not l.startswith('*')) |
| return (os_path.normpath(os_path.join(pydeps_dir, e)) for e in entries) |
| |
| def _CreateFilesToPydepsMap(self): |
| """Returns a map of local_path -> list_of_pydeps.""" |
| ret = {} |
| for pydep_local_path in self._pydeps_files: |
| for path in self._ComputeNormalizedPydepsEntries(pydep_local_path): |
| ret.setdefault(path, []).append(pydep_local_path) |
| return ret |
| |
| def ComputeAffectedPydeps(self): |
| """Returns an iterable of .pydeps files that might need regenerating.""" |
| affected_pydeps = set() |
| file_to_pydeps_map = None |
| for f in self._input_api.AffectedFiles(include_deletes=True): |
| local_path = f.LocalPath() |
| # Changes to DEPS can lead to .pydeps changes if any .py files are in |
| # subrepositories. We can't figure out which files change, so re-check |
| # all files. |
| # Changes to print_python_deps.py affect all .pydeps. |
| if local_path == 'DEPS' or local_path.endswith('print_python_deps.py'): |
| return self._pydeps_files |
| elif local_path.endswith('.pydeps'): |
| if local_path in self._pydeps_files: |
| affected_pydeps.add(local_path) |
| elif local_path.endswith('.py'): |
| if file_to_pydeps_map is None: |
| file_to_pydeps_map = self._CreateFilesToPydepsMap() |
| affected_pydeps.update(file_to_pydeps_map.get(local_path, ())) |
| return affected_pydeps |
| |
| def DetermineIfStale(self, pydeps_path): |
| """Runs print_python_deps.py to see if the files is stale.""" |
| import difflib |
| import os |
| |
| old_pydeps_data = self._LoadFile(pydeps_path).splitlines() |
| cmd = old_pydeps_data[1][1:].strip() |
| env = dict(os.environ) |
| env['PYTHONDONTWRITEBYTECODE'] = '1' |
| new_pydeps_data = self._input_api.subprocess.check_output( |
| cmd + ' --output ""', shell=True, env=env) |
| old_contents = old_pydeps_data[2:] |
| new_contents = new_pydeps_data.splitlines()[2:] |
| if old_pydeps_data[2:] != new_pydeps_data.splitlines()[2:]: |
| return cmd, '\n'.join(difflib.context_diff(old_contents, new_contents)) |
| |
| |
| def _CheckPydepsNeedsUpdating(input_api, output_api, checker_for_tests=None): |
| """Checks if a .pydeps file needs to be regenerated.""" |
| # This check is for Python dependency lists (.pydeps files), and involves |
| # paths not only in the PRESUBMIT.py, but also in the .pydeps files. It |
| # doesn't work on Windows and Mac, so skip it on other platforms. |
| if input_api.platform != 'linux2': |
| return [] |
| # TODO(agrieve): Update when there's a better way to detect |
| # this: crbug.com/570091 |
| is_android = input_api.os_path.exists('third_party/android_tools') |
| pydeps_files = _ALL_PYDEPS_FILES if is_android else _GENERIC_PYDEPS_FILES |
| results = [] |
| # First, check for new / deleted .pydeps. |
| for f in input_api.AffectedFiles(include_deletes=True): |
| # Check whether we are running the presubmit check for a file in src. |
| # f.LocalPath is relative to repo (src, or internal repo). |
| # os_path.exists is relative to src repo. |
| # Therefore if os_path.exists is true, it means f.LocalPath is relative |
| # to src and we can conclude that the pydeps is in src. |
| if input_api.os_path.exists(f.LocalPath()): |
| if f.LocalPath().endswith('.pydeps'): |
| if f.Action() == 'D' and f.LocalPath() in _ALL_PYDEPS_FILES: |
| results.append(output_api.PresubmitError( |
| 'Please update _ALL_PYDEPS_FILES within //PRESUBMIT.py to ' |
| 'remove %s' % f.LocalPath())) |
| elif f.Action() != 'D' and f.LocalPath() not in _ALL_PYDEPS_FILES: |
| results.append(output_api.PresubmitError( |
| 'Please update _ALL_PYDEPS_FILES within //PRESUBMIT.py to ' |
| 'include %s' % f.LocalPath())) |
| |
| if results: |
| return results |
| |
| checker = checker_for_tests or PydepsChecker(input_api, pydeps_files) |
| |
| for pydep_path in checker.ComputeAffectedPydeps(): |
| try: |
| result = checker.DetermineIfStale(pydep_path) |
| if result: |
| cmd, diff = result |
| results.append(output_api.PresubmitError( |
| 'File is stale: %s\nDiff (apply to fix):\n%s\n' |
| 'To regenerate, run:\n\n %s' % |
| (pydep_path, diff, cmd))) |
| except input_api.subprocess.CalledProcessError as error: |
| return [output_api.PresubmitError('Error running: %s' % error.cmd, |
| long_text=error.output)] |
| |
| return results |
| |
| |
| def _CheckSingletonInHeaders(input_api, output_api): |
| """Checks to make sure no header files have |Singleton<|.""" |
| def FileFilter(affected_file): |
| # It's ok for base/memory/singleton.h to have |Singleton<|. |
| black_list = (_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST + |
| (r"^base[\\/]memory[\\/]singleton\.h$", |
| r"^net[\\/]quic[\\/]platform[\\/]impl[\\/]" |
| r"quic_singleton_impl\.h$")) |
| return input_api.FilterSourceFile(affected_file, black_list=black_list) |
| |
| pattern = input_api.re.compile(r'(?<!class\sbase::)Singleton\s*<') |
| files = [] |
| for f in input_api.AffectedSourceFiles(FileFilter): |
| if (f.LocalPath().endswith('.h') or f.LocalPath().endswith('.hxx') or |
| f.LocalPath().endswith('.hpp') or f.LocalPath().endswith('.inl')): |
| contents = input_api.ReadFile(f) |
| for line in contents.splitlines(False): |
| if (not line.lstrip().startswith('//') and # Strip C++ comment. |
| pattern.search(line)): |
| files.append(f) |
| break |
| |
| if files: |
| return [output_api.PresubmitError( |
| 'Found base::Singleton<T> in the following header files.\n' + |
| 'Please move them to an appropriate source file so that the ' + |
| 'template gets instantiated in a single compilation unit.', |
| files) ] |
| return [] |
| |
| |
| _DEPRECATED_CSS = [ |
| # Values |
| ( "-webkit-box", "flex" ), |
| ( "-webkit-inline-box", "inline-flex" ), |
| ( "-webkit-flex", "flex" ), |
| ( "-webkit-inline-flex", "inline-flex" ), |
| ( "-webkit-min-content", "min-content" ), |
| ( "-webkit-max-content", "max-content" ), |
| |
| # Properties |
| ( "-webkit-background-clip", "background-clip" ), |
| ( "-webkit-background-origin", "background-origin" ), |
| ( "-webkit-background-size", "background-size" ), |
| ( "-webkit-box-shadow", "box-shadow" ), |
| ( "-webkit-user-select", "user-select" ), |
| |
| # Functions |
| ( "-webkit-gradient", "gradient" ), |
| ( "-webkit-repeating-gradient", "repeating-gradient" ), |
| ( "-webkit-linear-gradient", "linear-gradient" ), |
| ( "-webkit-repeating-linear-gradient", "repeating-linear-gradient" ), |
| ( "-webkit-radial-gradient", "radial-gradient" ), |
| ( "-webkit-repeating-radial-gradient", "repeating-radial-gradient" ), |
| ] |
| |
| |
| # TODO: add unit tests |
| def _CheckNoDeprecatedCss(input_api, output_api): |
| """ Make sure that we don't use deprecated CSS |
| properties, functions or values. Our external |
| documentation and iOS CSS for dom distiller |
| (reader mode) are ignored by the hooks as it |
| needs to be consumed by WebKit. """ |
| results = [] |
| file_inclusion_pattern = [r".+\.css$"] |
| black_list = (_EXCLUDED_PATHS + |
| _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST + |
| (r"^chrome/common/extensions/docs", |
| r"^chrome/docs", |
| r"^components/dom_distiller/core/css/distilledpage_ios.css", |
| r"^components/neterror/resources/neterror.css", |
| r"^native_client_sdk")) |
| file_filter = lambda f: input_api.FilterSourceFile( |
| f, white_list=file_inclusion_pattern, black_list=black_list) |
| for fpath in input_api.AffectedFiles(file_filter=file_filter): |
| for line_num, line in fpath.ChangedContents(): |
| for (deprecated_value, value) in _DEPRECATED_CSS: |
| if deprecated_value in line: |
| results.append(output_api.PresubmitError( |
| "%s:%d: Use of deprecated CSS %s, use %s instead" % |
| (fpath.LocalPath(), line_num, deprecated_value, value))) |
| return results |
| |
| |
| _DEPRECATED_JS = [ |
| ( "__lookupGetter__", "Object.getOwnPropertyDescriptor" ), |
| ( "__defineGetter__", "Object.defineProperty" ), |
| ( "__defineSetter__", "Object.defineProperty" ), |
| ] |
| |
| |
| # TODO: add unit tests |
| def _CheckNoDeprecatedJs(input_api, output_api): |
| """Make sure that we don't use deprecated JS in Chrome code.""" |
| results = [] |
| file_inclusion_pattern = [r".+\.js$"] # TODO(dbeam): .html? |
| black_list = (_EXCLUDED_PATHS + _TEST_CODE_EXCLUDED_PATHS + |
| input_api.DEFAULT_BLACK_LIST) |
| file_filter = lambda f: input_api.FilterSourceFile( |
| f, white_list=file_inclusion_pattern, black_list=black_list) |
| for fpath in input_api.AffectedFiles(file_filter=file_filter): |
| for lnum, line in fpath.ChangedContents(): |
| for (deprecated, replacement) in _DEPRECATED_JS: |
| if deprecated in line: |
| results.append(output_api.PresubmitError( |
| "%s:%d: Use of deprecated JS %s, use %s instead" % |
| (fpath.LocalPath(), lnum, deprecated, replacement))) |
| return results |
| |
| |
| def _CheckForRelativeIncludes(input_api, output_api): |
| # Need to set the sys.path so PRESUBMIT_test.py runs properly |
| import sys |
| original_sys_path = sys.path |
| try: |
| sys.path = sys.path + [input_api.os_path.join( |
| input_api.PresubmitLocalPath(), 'buildtools', 'checkdeps')] |
| from cpp_checker import CppChecker |
| finally: |
| # Restore sys.path to what it was before. |
| sys.path = original_sys_path |
| |
| bad_files = {} |
| for f in input_api.AffectedFiles(include_deletes=False): |
| if (f.LocalPath().startswith('third_party') and |
| not f.LocalPath().startswith('third_party/blink') and |
| not f.LocalPath().startswith('third_party\\blink')): |
| continue |
| |
| if not CppChecker.IsCppFile(f.LocalPath()): |
| continue |
| |
| relative_includes = [line for _, line in f.ChangedContents() |
| if "#include" in line and "../" in line] |
| if not relative_includes: |
| continue |
| bad_files[f.LocalPath()] = relative_includes |
| |
| if not bad_files: |
| return [] |
| |
| error_descriptions = [] |
| for file_path, bad_lines in bad_files.iteritems(): |
| error_description = file_path |
| for line in bad_lines: |
| error_description += '\n ' + line |
| error_descriptions.append(error_description) |
| |
| results = [] |
| results.append(output_api.PresubmitError( |
| 'You added one or more relative #include paths (including "../").\n' |
| 'These shouldn\'t be used because they can be used to include headers\n' |
| 'from code that\'s not correctly specified as a dependency in the\n' |
| 'relevant BUILD.gn file(s).', |
| error_descriptions)) |
| |
| return results |
| |
| |
| def _CheckWatchlistDefinitionsEntrySyntax(key, value, ast): |
| if not isinstance(key, ast.Str): |
| return 'Key at line %d must be a string literal' % key.lineno |
| if not isinstance(value, ast.Dict): |
| return 'Value at line %d must be a dict' % value.lineno |
| if len(value.keys) != 1: |
| return 'Dict at line %d must have single entry' % value.lineno |
| if not isinstance(value.keys[0], ast.Str) or value.keys[0].s != 'filepath': |
| return ( |
| 'Entry at line %d must have a string literal \'filepath\' as key' % |
| value.lineno) |
| return None |
| |
| |
| def _CheckWatchlistsEntrySyntax(key, value, ast, email_regex): |
| if not isinstance(key, ast.Str): |
| return 'Key at line %d must be a string literal' % key.lineno |
| if not isinstance(value, ast.List): |
| return 'Value at line %d must be a list' % value.lineno |
| for element in value.elts: |
| if not isinstance(element, ast.Str): |
| return 'Watchlist elements on line %d is not a string' % key.lineno |
| if not email_regex.match(element.s): |
| return ('Watchlist element on line %d doesn\'t look like a valid ' + |
| 'email: %s') % (key.lineno, element.s) |
| return None |
| |
| |
| def _CheckWATCHLISTSEntries(wd_dict, w_dict, input_api): |
| mismatch_template = ( |
| 'Mismatch between WATCHLIST_DEFINITIONS entry (%s) and WATCHLISTS ' |
| 'entry (%s)') |
| |
| email_regex = input_api.re.compile( |
| r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+$") |
| |
| ast = input_api.ast |
| i = 0 |
| last_key = '' |
| while True: |
| if i >= len(wd_dict.keys): |
| if i >= len(w_dict.keys): |
| return None |
| return mismatch_template % ('missing', 'line %d' % w_dict.keys[i].lineno) |
| elif i >= len(w_dict.keys): |
| return ( |
| mismatch_template % ('line %d' % wd_dict.keys[i].lineno, 'missing')) |
| |
| wd_key = wd_dict.keys[i] |
| w_key = w_dict.keys[i] |
| |
| result = _CheckWatchlistDefinitionsEntrySyntax( |
| wd_key, wd_dict.values[i], ast) |
| if result is not None: |
| return 'Bad entry in WATCHLIST_DEFINITIONS dict: %s' % result |
| |
| result = _CheckWatchlistsEntrySyntax( |
| w_key, w_dict.values[i], ast, email_regex) |
| if result is not None: |
| return 'Bad entry in WATCHLISTS dict: %s' % result |
| |
| if wd_key.s != w_key.s: |
| return mismatch_template % ( |
| '%s at line %d' % (wd_key.s, wd_key.lineno), |
| '%s at line %d' % (w_key.s, w_key.lineno)) |
| |
| if wd_key.s < last_key: |
| return ( |
| 'WATCHLISTS dict is not sorted lexicographically at line %d and %d' % |
| (wd_key.lineno, w_key.lineno)) |
| last_key = wd_key.s |
| |
| i = i + 1 |
| |
| |
| def _CheckWATCHLISTSSyntax(expression, input_api): |
| ast = input_api.ast |
| if not isinstance(expression, ast.Expression): |
| return 'WATCHLISTS file must contain a valid expression' |
| dictionary = expression.body |
| if not isinstance(dictionary, ast.Dict) or len(dictionary.keys) != 2: |
| return 'WATCHLISTS file must have single dict with exactly two entries' |
| |
| first_key = dictionary.keys[0] |
| first_value = dictionary.values[0] |
| second_key = dictionary.keys[1] |
| second_value = dictionary.values[1] |
| |
| if (not isinstance(first_key, ast.Str) or |
| first_key.s != 'WATCHLIST_DEFINITIONS' or |
| not isinstance(first_value, ast.Dict)): |
| return ( |
| 'The first entry of the dict in WATCHLISTS file must be ' |
| 'WATCHLIST_DEFINITIONS dict') |
| |
| if (not isinstance(second_key, ast.Str) or |
| second_key.s != 'WATCHLISTS' or |
| not isinstance(second_value, ast.Dict)): |
| return ( |
| 'The second entry of the dict in WATCHLISTS file must be ' |
| 'WATCHLISTS dict' |