Replacing the 'return 0;' statements with 'return nullptr;'

public/platform/Platform.h

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 116 matching lines @@
     typedef HANDLE FileHandle;
 #else
     typedef int FileHandle;
 #endif
 
     BLINK_PLATFORM_EXPORT static void initialize(Platform*);
     BLINK_PLATFORM_EXPORT static void shutdown();
     BLINK_PLATFORM_EXPORT static Platform* current();
 
     // May return null.
-    virtual WebCookieJar* cookieJar() { return 0; }
+    virtual WebCookieJar* cookieJar() { return nullptr; }
 
     // Must return non-null.
-    virtual WebClipboard* clipboard() { return 0; }
+    virtual WebClipboard* clipboard() { return nullptr; }
 
     // Must return non-null.
-    virtual WebFileUtilities* fileUtilities() { return 0; }
+    virtual WebFileUtilities* fileUtilities() { return nullptr; }
 
     // Must return non-null.
-    virtual WebMimeRegistry* mimeRegistry() { return 0; }
+    virtual WebMimeRegistry* mimeRegistry() { return nullptr; }
 
     // May return null if sandbox support is not necessary
-    virtual WebSandboxSupport* sandboxSupport() { return 0; }
+    virtual WebSandboxSupport* sandboxSupport() { return nullptr; }
 
     // May return null on some platforms.
-    virtual WebThemeEngine* themeEngine() { return 0; }
+    virtual WebThemeEngine* themeEngine() { return nullptr; }
 
-    virtual WebFallbackThemeEngine* fallbackThemeEngine() { return 0; }
+    virtual WebFallbackThemeEngine* fallbackThemeEngine() { return nullptr; }
 
     // May return null.
-    virtual WebSpeechSynthesizer* createSpeechSynthesizer(WebSpeechSynthesizerClient*) { return 0; }
+    virtual WebSpeechSynthesizer* createSpeechSynthesizer(WebSpeechSynthesizerClient*) { return nullptr; }
 
 
     // Audio --------------------------------------------------------------
 
     virtual double audioHardwareSampleRate() { return 0; }
     virtual size_t audioHardwareBufferSize() { return 0; }
     virtual unsigned audioHardwareOutputChannels() { return 0; }
 
     // Creates a device for audio I/O.
     // Pass in (numberOfInputChannels > 0) if live/local audio input is desired.
-    virtual WebAudioDevice* createAudioDevice(size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfChannels, double sampleRate, WebAudioDevice::RenderCallback*, const WebString& deviceId) { return 0; }
+    virtual WebAudioDevice* createAudioDevice(size_t bufferSize, unsigned numberOfInputChannels, unsigned numberOfChannels, double sampleRate, WebAudioDevice::RenderCallback*, const WebString& deviceId) { return nullptr; }
 
 
     // MIDI ----------------------------------------------------------------
 
     // Creates a platform dependent WebMIDIAccessor. MIDIAccessor under platform
     // creates and owns it.
-    virtual WebMIDIAccessor* createMIDIAccessor(WebMIDIAccessorClient*) { return 0; }
+    virtual WebMIDIAccessor* createMIDIAccessor(WebMIDIAccessorClient*) { return nullptr; }
 
 
     // Blob ----------------------------------------------------------------
 
     // Must return non-null.
-    virtual WebBlobRegistry* blobRegistry() { return 0; }
+    virtual WebBlobRegistry* blobRegistry() { return nullptr; }
 
     // Database ------------------------------------------------------------
 
     // Opens a database file; dirHandle should be 0 if the caller does not need
     // a handle to the directory containing this file
     virtual FileHandle databaseOpenFile(const WebString& vfsFileName, int desiredFlags) { return FileHandle(); }
 
     // Deletes a database file and returns the error code
     virtual int databaseDeleteFile(const WebString& vfsFileName, bool syncDir) { return 0; }
 
     // Returns the attributes of the given database file
     virtual long databaseGetFileAttributes(const WebString& vfsFileName) { return 0; }
 
     // Returns the size of the given database file
     virtual long long databaseGetFileSize(const WebString& vfsFileName) { return 0; }
 
     // Returns the space available for the given origin
     virtual long long databaseGetSpaceAvailableForOrigin(const WebString& originIdentifier) { return 0; }
 
     // Set the size of the given database file
     virtual bool databaseSetFileSize(const WebString& vfsFileName, long long size) { return false; }
 
 
     // DOM Storage --------------------------------------------------
 
     // Return a LocalStorage namespace
-    virtual WebStorageNamespace* createLocalStorageNamespace() { return 0; }
+    virtual WebStorageNamespace* createLocalStorageNamespace() { return nullptr; }
 
 
     // FileSystem ----------------------------------------------------------
 
     // Must return non-null.
-    virtual WebFileSystem* fileSystem() { return 0; }
+    virtual WebFileSystem* fileSystem() { return nullptr; }
 
 
     // IDN conversion ------------------------------------------------------
 
     virtual WebString convertIDNToUnicode(const WebString& host, const WebString& languages) { return host; }
 
 
     // IndexedDB ----------------------------------------------------------
 
     // Must return non-null.
-    virtual WebIDBFactory* idbFactory() { return 0; }
+    virtual WebIDBFactory* idbFactory() { return nullptr; }
 
 
     // Cache Storage ----------------------------------------------------------
 
     // The caller is responsible for deleting the returned object.
     virtual WebServiceWorkerCacheStorage* cacheStorage(const WebString& originIdentifier) { return nullptr; }
 
     // Gamepad -------------------------------------------------------------
 
     virtual void sampleGamepads(WebGamepads& into) { into.length = 0; }
@@ skipping 42 matching lines @@
 
     // Returns private and shared usage, in bytes. Private bytes is the amount of
     // memory currently allocated to this process that cannot be shared. Returns
     // false on platform specific error conditions.
     virtual bool processMemorySizesInBytes(size_t* privateBytes, size_t* sharedBytes) { return false; }
 
     // Reports number of bytes used by memory allocator for internal needs.
     // Returns true if the size has been reported, or false otherwise.
     virtual bool memoryAllocatorWasteInBytes(size_t*) { return false; }
 
-    // Allocates discardable memory. May return 0, even if the platform supports
+    // Allocates discardable memory. May return nullptr, even if the platform supports
     // discardable memory. If nonzero, however, then the WebDiscardableMmeory is
     // returned in an locked state. You may use its underlying data() member
     // directly, taking care to unlock it when you are ready to let it become
     // discardable.
-    virtual WebDiscardableMemory* allocateAndLockDiscardableMemory(size_t bytes) { return 0; }
+    virtual WebDiscardableMemory* allocateAndLockDiscardableMemory(size_t bytes) { return nullptr; }
 
     static const size_t noDecodedImageByteLimit = static_cast<size_t>(-1);
 
     // Returns the maximum amount of memory a decoded image should be allowed.
     // See comments on ImageDecoder::m_maxDecodedBytes.
     virtual size_t maxDecodedImageBytes() { return noDecodedImageByteLimit; }
 
 
     // Message Ports -------------------------------------------------------
 
     // Creates a Message Port Channel pair. This can be called on any thread.
     // The returned objects should only be used on the thread they were created on.
     virtual void createMessageChannel(WebMessagePortChannel** channel1, WebMessagePortChannel** channel2) { *channel1 = 0; *channel2 = 0; }
 
 
     // Network -------------------------------------------------------------
 
     // Returns a new WebURLLoader instance.
-    virtual WebURLLoader* createURLLoader() { return 0; }
+    virtual WebURLLoader* createURLLoader() { return nullptr; }
 
     // May return null.
-    virtual WebPrescientNetworking* prescientNetworking() { return 0; }
+    virtual WebPrescientNetworking* prescientNetworking() { return nullptr; }
 
     // Returns a new WebSocketHandle instance.
-    virtual WebSocketHandle* createWebSocketHandle() { return 0; }
+    virtual WebSocketHandle* createWebSocketHandle() { return nullptr; }
 
     // Returns the User-Agent string.
     virtual WebString userAgent() { return WebString(); }
 
     // A suggestion to cache this metadata in association with this URL.
     virtual void cacheMetadata(const WebURL&, int64 responseTime, const char* data, size_t dataSize) { }
 
     // Returns the decoded data url if url had a supported mimetype and parsing was successful.
     virtual WebData parseDataURL(const WebURL&, WebString& mimetype, WebString& charset) { return WebData(); }
 
     virtual WebURLError cancelledError(const WebURL&) const { return WebURLError(); }
 
     virtual bool isReservedIPAddress(const WebString& host) const { return false; }
 
     virtual bool portAllowed(const WebURL&) const { return false; }
 
     // Plugins -------------------------------------------------------------
 
     // If refresh is true, then cached information should not be used to
     // satisfy this call.
     virtual void getPluginList(bool refresh, WebPluginListBuilder*) { }
 
 
     // Public Suffix List --------------------------------------------------
 
     // May return null on some platforms.
-    virtual WebPublicSuffixList* publicSuffixList() { return 0; }
+    virtual WebPublicSuffixList* publicSuffixList() { return nullptr; }
 
 
     // Resources -----------------------------------------------------------
 
     // Returns a localized string resource (with substitution parameters).
     virtual WebString queryLocalizedString(WebLocalizedString::Name) { return WebString(); }
     virtual WebString queryLocalizedString(WebLocalizedString::Name, const WebString& parameter) { return WebString(); }
     virtual WebString queryLocalizedString(WebLocalizedString::Name, const WebString& parameter1, const WebString& parameter2) { return WebString(); }
 
 
     // Threads -------------------------------------------------------
 
     // Creates an embedder-defined thread.
-    virtual WebThread* createThread(const char* name) { return 0; }
+    virtual WebThread* createThread(const char* name) { return nullptr; }
 
     // Returns an interface to the current thread. This is owned by the
     // embedder.
-    virtual WebThread* currentThread() { return 0; }
+    virtual WebThread* currentThread() { return nullptr; }
 
     // Yield the current thread so another thread can be scheduled.
     virtual void yieldCurrentThread() { }
 
     // WaitableEvent -------------------------------------------------------
 
     // Creates an embedder-defined waitable event object.
-    virtual WebWaitableEvent* createWaitableEvent() { return 0; }
+    virtual WebWaitableEvent* createWaitableEvent() { return nullptr; }
 
     // Waits on multiple events and returns the event object that has been
-    // signaled. This may return 0 if it fails to wait events.
+    // signaled. This may return nullptr if it fails to wait events.
     // Any event objects given to this method must not deleted while this
     // wait is happening.
-    virtual WebWaitableEvent* waitMultipleEvents(const WebVector<WebWaitableEvent*>& events) { return 0; }
+    virtual WebWaitableEvent* waitMultipleEvents(const WebVector<WebWaitableEvent*>& events) { return nullptr; }
 
 
     // Profiling -----------------------------------------------------------
 
     virtual void decrementStatsCounter(const char* name) { }
     virtual void incrementStatsCounter(const char* name) { }
 
 
     // Resources -----------------------------------------------------------
 
     // Returns a blob of data corresponding to the named resource.
     virtual WebData loadResource(const char* name) { return WebData(); }
 
     // Decodes the in-memory audio file data and returns the linear PCM audio data in the destinationBus.
     // A sample-rate conversion to sampleRate will occur if the file data is at a different sample-rate.
     // Returns true on success.
     virtual bool loadAudioResource(WebAudioBus* destinationBus, const char* audioFileData, size_t dataSize) { return false; }
 
     // Screen -------------------------------------------------------------
 
     // Supplies the system monitor color profile.
     virtual void screenColorProfile(WebVector<char>* profile) { }
 
 
     // Scrollbar ----------------------------------------------------------
 
     // Must return non-null.
-    virtual WebScrollbarBehavior* scrollbarBehavior() { return 0; }
+    virtual WebScrollbarBehavior* scrollbarBehavior() { return nullptr; }
 
 
     // Sudden Termination --------------------------------------------------
 
     // Disable/Enable sudden termination on a process level. When possible, it
     // is preferable to disable sudden termination on a per-frame level via
     // WebFrameClient::suddenTerminationDisablerChanged.
     virtual void suddenTerminationChanged(bool enabled) { }
 
 
@@ skipping 32 matching lines @@
     // vibration it will be cancelled before the new one is started.
     virtual void vibrate(unsigned time) { }
 
     // Cancels the current vibration, if there is one.
     virtual void cancelVibration() { }
 
 
     // Testing -------------------------------------------------------------
 
     // Get a pointer to testing support interfaces. Will not be available in production builds.
-    virtual WebUnitTestSupport* unitTestSupport() { return 0; }
+    virtual WebUnitTestSupport* unitTestSupport() { return nullptr; }
 
 
     // Tracing -------------------------------------------------------------
 
     // Get a pointer to the enabled state of the given trace category. The
     // embedder can dynamically change the enabled state as trace event
     // recording is started and stopped by the application. Only long-lived
     // literal strings should be given as the category name. The implementation
     // expects the returned pointer to be held permanently in a local static. If
     // the unsigned char is non-zero, tracing is enabled. If tracing is enabled,
     // addTraceEvent is expected to be called by the trace event macros.
-    virtual const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) { return 0; }
+    virtual const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) { return nullptr; }
 
     typedef intptr_t TraceEventAPIAtomicWord;
 
     // Get a pointer to a global state of the given thread. An embedder is
     // expected to update the global state as the state of the embedder changes.
     // A sampling thread in the Chromium side reads the global state periodically
     // and reflects the sampling profiled results into about:tracing.
-    virtual TraceEventAPIAtomicWord* getTraceSamplingState(const unsigned bucketName) { return 0; }
+    virtual TraceEventAPIAtomicWord* getTraceSamplingState(const unsigned bucketName) { return nullptr; }
 
     typedef uint64_t TraceEventHandle;
 
     // Add a trace event to the platform tracing system. Depending on the actual
     // enabled state, this event may be recorded or dropped.
     // - phase specifies the type of event:
     //   - BEGIN ('B'): Marks the beginning of a scoped event.
     //   - END ('E'): Marks the end of a scoped event.
     //   - COMPLETE ('X'): Marks the beginning of a scoped event, but doesn't
     //     need a matching END event. Instead, at the end of the scope,
@@ skipping 88 matching lines @@
     virtual void registerMemoryDumpProvider(blink::WebMemoryDumpProvider*) { }
 
     // Must be called on the thread that called registerMemoryDumpProvider().
     virtual void unregisterMemoryDumpProvider(blink::WebMemoryDumpProvider*) { }
 
     // GPU ----------------------------------------------------------------
     //
     // May return null if GPU is not supported.
     // Returns newly allocated and initialized offscreen WebGraphicsContext3D instance.
     // Passing an existing context to shareContext will create the new context in the same share group as the passed context.
-    virtual WebGraphicsContext3D* createOffscreenGraphicsContext3D(const WebGraphicsContext3D::Attributes&, WebGraphicsContext3D* shareContext) { return 0; }
-    virtual WebGraphicsContext3D* createOffscreenGraphicsContext3D(const WebGraphicsContext3D::Attributes&, WebGraphicsContext3D* shareContext, WebGLInfo* glInfo) { return 0; }
-    virtual WebGraphicsContext3D* createOffscreenGraphicsContext3D(const WebGraphicsContext3D::Attributes&) { return 0; }
+    virtual WebGraphicsContext3D* createOffscreenGraphicsContext3D(const WebGraphicsContext3D::Attributes&, WebGraphicsContext3D* shareContext) { return nullptr; }
+    virtual WebGraphicsContext3D* createOffscreenGraphicsContext3D(const WebGraphicsContext3D::Attributes&, WebGraphicsContext3D* shareContext, WebGLInfo* glInfo) { return nullptr; }
+    virtual WebGraphicsContext3D* createOffscreenGraphicsContext3D(const WebGraphicsContext3D::Attributes&) { return nullptr; }
 
     // Returns a newly allocated and initialized offscreen context provider. The provider may return a null
     // graphics context if GPU is not supported.
-    virtual WebGraphicsContext3DProvider* createSharedOffscreenGraphicsContext3DProvider() { return 0; }
+    virtual WebGraphicsContext3DProvider* createSharedOffscreenGraphicsContext3DProvider() { return nullptr; }
 
     // Returns true if the platform is capable of producing an offscreen context suitable for accelerating 2d canvas.
     // This will return false if the platform cannot promise that contexts will be preserved across operations like
     // locking the screen or if the platform cannot provide a context with suitable performance characteristics.
     //
     // This value must be checked again after a context loss event as the platform's capabilities may have changed.
     virtual bool canAccelerate2dCanvas() { return false; }
 
     virtual bool isThreadedCompositingEnabled() { return false; }
 
-    virtual WebCompositorSupport* compositorSupport() { return 0; }
+    virtual WebCompositorSupport* compositorSupport() { return nullptr; }
 
-    virtual WebFlingAnimator* createFlingAnimator() { return 0; }
+    virtual WebFlingAnimator* createFlingAnimator() { return nullptr; }
 
     // Creates a new fling animation curve instance for device |deviceSource|
     // with |velocity| and already scrolled |cumulativeScroll| pixels.
-    virtual WebGestureCurve* createFlingAnimationCurve(WebGestureDevice deviceSource, const WebFloatPoint& velocity, const WebSize& cumulativeScroll) { return 0; }
+    virtual WebGestureCurve* createFlingAnimationCurve(WebGestureDevice deviceSource, const WebFloatPoint& velocity, const WebSize& cumulativeScroll) { return nullptr; }
 
     // WebRTC ----------------------------------------------------------
 
     // Creates an WebRTCPeerConnectionHandler for RTCPeerConnection.
     // May return null if WebRTC functionality is not avaliable or out of resources.
-    virtual WebRTCPeerConnectionHandler* createRTCPeerConnectionHandler(WebRTCPeerConnectionHandlerClient*) { return 0; }
+    virtual WebRTCPeerConnectionHandler* createRTCPeerConnectionHandler(WebRTCPeerConnectionHandlerClient*) { return nullptr; }
 
     // May return null if WebRTC functionality is not avaliable or out of resources.
-    virtual WebMediaStreamCenter* createMediaStreamCenter(WebMediaStreamCenterClient*) { return 0; }
+    virtual WebMediaStreamCenter* createMediaStreamCenter(WebMediaStreamCenterClient*) { return nullptr; }
 
 
     // WebWorker ----------------------------------------------------------
 
     virtual void didStartWorkerRunLoop() { }
     virtual void didStopWorkerRunLoop() { }
 
     // WebCrypto ----------------------------------------------------------
 
-    virtual WebCrypto* crypto() { return 0; }
+    virtual WebCrypto* crypto() { return nullptr; }
 
 
     // Platform events -----------------------------------------------------
     // Device Orientation, Device Motion, Device Light, Battery, Gamepad.
 
     // Request the platform to start listening to the events of the specified
     // type and notify the given listener (if not null) when there is an update.
     virtual void startListening(WebPlatformEventType type, WebPlatformEventListener* listener) { }
 
     // Request the platform to stop listening to the specified event and no
@@ skipping 32 matching lines @@
     // an error occurs WebStorageQuotaCallbacks::didFail is called with an
     // error code.
     virtual void queryStorageUsageAndQuota(
         const WebURL& storagePartition,
         WebStorageQuotaType,
         WebStorageQuotaCallbacks) { }
 
 
     // WebDatabase --------------------------------------------------------
 
-    virtual WebDatabaseObserver* databaseObserver() { return 0; }
+    virtual WebDatabaseObserver* databaseObserver() { return nullptr; }
 
 
     // Web Notifications --------------------------------------------------
 
-    virtual WebNotificationManager* notificationManager() { return 0; }
+    virtual WebNotificationManager* notificationManager() { return nullptr; }
 
 
     // Geofencing ---------------------------------------------------------
 
-    virtual WebGeofencingProvider* geofencingProvider() { return 0; }
+    virtual WebGeofencingProvider* geofencingProvider() { return nullptr; }
 
 
     // Bluetooth ----------------------------------------------------------
 
     // Returns pointer to client owned WebBluetooth implementation.
-    virtual WebBluetooth* bluetooth() { return 0; }
+    virtual WebBluetooth* bluetooth() { return nullptr; }
 
 
     // Push API------------------------------------------------------------
 
-    virtual WebPushProvider* pushProvider() { return 0; }
+    virtual WebPushProvider* pushProvider() { return nullptr; }
 
 
     // navigator.connect --------------------------------------------------
 
-    virtual WebNavigatorConnectProvider* navigatorConnectProvider() { return 0; }
+    virtual WebNavigatorConnectProvider* navigatorConnectProvider() { return nullptr; }
 
     // Permissions --------------------------------------------------------
 
-    virtual WebPermissionClient* permissionClient() { return 0; }
+    virtual WebPermissionClient* permissionClient() { return nullptr; }
 
 
     // Background Sync API------------------------------------------------------------
 
-    virtual WebSyncProvider* backgroundSyncProvider() { return 0; }
+    virtual WebSyncProvider* backgroundSyncProvider() { return nullptr; }
 
 protected:
     BLINK_PLATFORM_EXPORT Platform();
     virtual ~Platform() { }
 
     WebThread* m_mainThread;
 };
 
 } // namespace blink
 
 #endif