Small cleanups in the Mojo HTML viewer

This CL removes the "override" keyword from all Blink API implementations.
We don't use the keyword for the Blink API since it's in a different
repository, and it makes changes to the API much harder.

Additionally, clean up some minor camelCase -> under_score variables.

R=sky@chromium.org
BUG=

Review URL: https://codereview.chromium.org/1090953002

Cr-Commit-Position: refs/heads/master@{#325468}

mojo/services/html_viewer/blink_platform_impl.h

@@ -23,46 +23,46 @@ namespace html_viewer {
 class BlinkPlatformImpl : public blink::Platform {
  public:
   explicit BlinkPlatformImpl();
-  ~BlinkPlatformImpl() override;
+  virtual ~BlinkPlatformImpl();
 
   // blink::Platform methods:
-  blink::WebMimeRegistry* mimeRegistry() override;
-  blink::WebThemeEngine* themeEngine() override;
-  blink::WebScheduler* scheduler() override;
-  blink::WebString defaultLocale() override;
-  double currentTime() override;
-  double monotonicallyIncreasingTime() override;
-  void cryptographicallyRandomValues(unsigned char* buffer,
-                                     size_t length) override;
-  void setSharedTimerFiredFunction(void (*func)()) override;
-  void setSharedTimerFireInterval(double interval_seconds) override;
-  void stopSharedTimer() override;
+  virtual blink::WebMimeRegistry* mimeRegistry();
+  virtual blink::WebThemeEngine* themeEngine();
+  virtual blink::WebScheduler* scheduler();
+  virtual blink::WebString defaultLocale();
+  virtual double currentTime();
+  virtual double monotonicallyIncreasingTime();
+  virtual void cryptographicallyRandomValues(unsigned char* buffer,
+                                             size_t length);
+  virtual void setSharedTimerFiredFunction(void (*func)());
+  virtual void setSharedTimerFireInterval(double interval_seconds);
+  virtual void stopSharedTimer();
   virtual void callOnMainThread(void (*func)(void*), void* context);
-  bool isThreadedCompositingEnabled() override;
-  blink::WebCompositorSupport* compositorSupport() override;
-  blink::WebURLLoader* createURLLoader() override;
-  blink::WebSocketHandle* createWebSocketHandle() override;
-  blink::WebString userAgent() override;
-  blink::WebData parseDataURL(
+  virtual bool isThreadedCompositingEnabled();
+  virtual blink::WebCompositorSupport* compositorSupport();
+  virtual blink::WebURLLoader* createURLLoader();
+  virtual blink::WebSocketHandle* createWebSocketHandle();
+  virtual blink::WebString userAgent();
+  virtual blink::WebData parseDataURL(
       const blink::WebURL& url, blink::WebString& mime_type,
-      blink::WebString& charset) override;
-  bool isReservedIPAddress(const blink::WebString& host) const override;
-  blink::WebURLError cancelledError(const blink::WebURL& url) const override;
-  blink::WebThread* createThread(const char* name) override;
-  blink::WebThread* currentThread() override;
-  void yieldCurrentThread() override;
-  blink::WebWaitableEvent* createWaitableEvent() override;
-  blink::WebWaitableEvent* waitMultipleEvents(
-      const blink::WebVector<blink::WebWaitableEvent*>& events) override;
-  blink::WebScrollbarBehavior* scrollbarBehavior() override;
-  const unsigned char* getTraceCategoryEnabledFlag(
-      const char* category_name) override;
-  blink::WebData loadResource(const char* name) override;
-  blink::WebGestureCurve* createFlingAnimationCurve(
+      blink::WebString& charset);
+  virtual bool isReservedIPAddress(const blink::WebString& host) const;
+  virtual blink::WebURLError cancelledError(const blink::WebURL& url) const;
+  virtual blink::WebThread* createThread(const char* name);
+  virtual blink::WebThread* currentThread();
+  virtual void yieldCurrentThread();
+  virtual blink::WebWaitableEvent* createWaitableEvent();
+  virtual blink::WebWaitableEvent* waitMultipleEvents(
+      const blink::WebVector<blink::WebWaitableEvent*>& events);
+  virtual blink::WebScrollbarBehavior* scrollbarBehavior();
+  virtual const unsigned char* getTraceCategoryEnabledFlag(
+      const char* category_name);
+  virtual blink::WebData loadResource(const char* name);
+  virtual blink::WebGestureCurve* createFlingAnimationCurve(
       blink::WebGestureDevice device_source,
       const blink::WebFloatPoint& velocity,
-      const blink::WebSize& cumulative_scroll) override;
-  blink::WebNotificationManager* notificationManager() override;
+      const blink::WebSize& cumulative_scroll);
+  virtual blink::WebNotificationManager* notificationManager();
 
  private:
   void SuspendSharedTimer();

mojo/services/html_viewer/html_document.h

@@ -76,7 +76,7 @@ class HTMLDocument : public blink::WebViewClient,
   void UpdateWebviewSizeFromViewSize();
 
   // WebViewClient methods:
-  blink::WebStorageNamespace* createSessionStorageNamespace() override;
+  virtual blink::WebStorageNamespace* createSessionStorageNamespace();
 
   // WebWidgetClient methods:
   void initializeLayerTreeView() override;
@@ -87,33 +87,33 @@ class HTMLDocument : public blink::WebViewClient,
       blink::WebLocalFrame* frame,
       const blink::WebURL& url,
       blink::WebMediaPlayerClient* client);
-  blink::WebMediaPlayer* createMediaPlayer(
+  virtual blink::WebMediaPlayer* createMediaPlayer(
       blink::WebLocalFrame* frame,
       const blink::WebURL& url,
       blink::WebMediaPlayerClient* client,
-      blink::WebContentDecryptionModule* initial_cdm) override;
-  blink::WebFrame* createChildFrame(
+      blink::WebContentDecryptionModule* initial_cdm);
+  virtual blink::WebFrame* createChildFrame(
       blink::WebLocalFrame* parent,
       const blink::WebString& frameName,
-      blink::WebSandboxFlags sandboxFlags) override;
-  void frameDetached(blink::WebFrame*) override;
-  blink::WebCookieJar* cookieJar(blink::WebLocalFrame* frame) override;
-  blink::WebNavigationPolicy decidePolicyForNavigation(
+      blink::WebSandboxFlags sandboxFlags);
+  virtual void frameDetached(blink::WebFrame*);
+  virtual blink::WebCookieJar* cookieJar(blink::WebLocalFrame* frame);
+  virtual blink::WebNavigationPolicy decidePolicyForNavigation(
       blink::WebLocalFrame* frame,
       blink::WebDataSource::ExtraData* data,
       const blink::WebURLRequest& request,
       blink::WebNavigationType nav_type,
       blink::WebNavigationPolicy default_policy,
-      bool isRedirect) override;
-  void didAddMessageToConsole(const blink::WebConsoleMessage& message,
+      bool isRedirect);
+  virtual void didAddMessageToConsole(const blink::WebConsoleMessage& message,
                                       const blink::WebString& source_name,
                                       unsigned source_line,
-                              const blink::WebString& stack_trace) override;
-  void didFinishLoad(blink::WebLocalFrame* frame) override;
-  void didNavigateWithinPage(blink::WebLocalFrame* frame,
+                                      const blink::WebString& stack_trace);
+  virtual void didFinishLoad(blink::WebLocalFrame* frame);
+  virtual void didNavigateWithinPage(blink::WebLocalFrame* frame,
                                      const blink::WebHistoryItem& history_item,
-                             blink::WebHistoryCommitType commit_type) override;
-  blink::WebEncryptedMediaClient* encryptedMediaClient() override;
+                                     blink::WebHistoryCommitType commit_type);
+  virtual blink::WebEncryptedMediaClient* encryptedMediaClient();
 
   // ViewManagerDelegate methods:
   void OnEmbed(mojo::View* root,

mojo/services/html_viewer/mojo_blink_platform_impl.h

@@ -25,8 +25,8 @@ class MojoBlinkPlatformImpl : public BlinkPlatformImpl {
 
  private:
   // BlinkPlatform
-  blink::WebCookieJar* cookieJar() override;
-  blink::WebClipboard* clipboard() override;
+  virtual blink::WebCookieJar* cookieJar();
+  virtual blink::WebClipboard* clipboard();
 
   blink::WebURLLoader* createURLLoader() override;
   blink::WebSocketHandle* createWebSocketHandle() override;

mojo/services/html_viewer/test_blink_platform_impl.h

@@ -19,8 +19,8 @@ class TestBlinkPlatformImpl : public BlinkPlatformImpl {
 
  private:
   // blink::Platform methods:
-  blink::WebCookieJar* cookieJar() override;
-  blink::WebClipboard* clipboard() override;
+  virtual blink::WebCookieJar* cookieJar();
+  virtual blink::WebClipboard* clipboard();
 
   blink::WebClipboard clipboard_;
   blink::WebCookieJar cookie_jar_;

mojo/services/html_viewer/webclipboard_impl.cc

@@ -100,7 +100,7 @@ bool WebClipboardImpl::isFormatAvailable(Format format, Buffer buffer) {
 
 blink::WebVector<blink::WebString> WebClipboardImpl::readAvailableTypes(
     Buffer buffer,
-    bool* containsFilenames) {
+    bool* contains_filenames) {
   Clipboard::Type clipboard_type = ConvertBufferType(buffer);
 
   std::vector<std::string> types;
@@ -110,8 +110,8 @@ blink::WebVector<blink::WebString> WebClipboardImpl::readAvailableTypes(
   // Force this to be synchronous.
   clipboard_.WaitForIncomingMethodCall();
 
-  // AFAICT, every instance of setting containsFilenames is false.
-  *containsFilenames = false;
+  // AFAICT, every instance of setting contains_filenames is false.
+  *contains_filenames = false;
 
   blink::WebVector<blink::WebString> output(types.size());
   for (size_t i = 0; i < types.size(); ++i) {
@@ -135,9 +135,9 @@ blink::WebString WebClipboardImpl::readPlainText(Buffer buffer) {
 }
 
 blink::WebString WebClipboardImpl::readHTML(Buffer buffer,
-                                            blink::WebURL* pageURL,
-                                            unsigned* fragmentStart,
-                                            unsigned* fragmentEnd) {
+                                            blink::WebURL* page_url,
+                                            unsigned* fragment_start,
+                                            unsigned* fragment_end) {
   Clipboard::Type type = ConvertBufferType(buffer);
 
   blink::WebString html;
@@ -145,11 +145,11 @@ blink::WebString WebClipboardImpl::readHTML(Buffer buffer,
                            base::Bind(&CopyWebString, &html));
   clipboard_.WaitForIncomingMethodCall();
 
-  *fragmentStart = 0;
-  *fragmentEnd = static_cast<unsigned>(html.length());
+  *fragment_start = 0;
+  *fragment_end = static_cast<unsigned>(html.length());
 
   clipboard_->ReadMimeType(type, Clipboard::MIME_TYPE_URL,
-                           base::Bind(&CopyURL, pageURL));
+                           base::Bind(&CopyURL, page_url));
   clipboard_.WaitForIncomingMethodCall();
 
   return html;
@@ -170,21 +170,21 @@ blink::WebString WebClipboardImpl::readCustomData(
   return data;
 }
 
-void WebClipboardImpl::writePlainText(const blink::WebString& text) {
+void WebClipboardImpl::writePlainText(const blink::WebString& plain_text) {
   Map<String, Array<uint8_t>> data;
-  data[Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(text);
+  data[Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(plain_text);
 
   clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE, data.Pass());
 }
 
-void WebClipboardImpl::writeHTML(const blink::WebString& htmlText,
-                                 const blink::WebURL& url,
-                                 const blink::WebString& plainText,
+void WebClipboardImpl::writeHTML(const blink::WebString& html_text,
+                                 const blink::WebURL& source_url,
+                                 const blink::WebString& plain_text,
                                  bool writeSmartPaste) {
   Map<String, Array<uint8_t>> data;
-  data[Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(plainText);
-  data[Clipboard::MIME_TYPE_HTML] = Array<uint8_t>::From(htmlText);
-  data[Clipboard::MIME_TYPE_URL] = Array<uint8_t>::From(url.string());
+  data[Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(plain_text);
+  data[Clipboard::MIME_TYPE_HTML] = Array<uint8_t>::From(html_text);
+  data[Clipboard::MIME_TYPE_URL] = Array<uint8_t>::From(source_url.string());
 
   if (writeSmartPaste)
     data[kMimeTypeWebkitSmartPaste] = Array<uint8_t>::From(blink::WebString());

mojo/services/html_viewer/webclipboard_impl.h

@@ -16,24 +16,24 @@ class WebClipboardImpl : public blink::WebClipboard {
   virtual ~WebClipboardImpl();
 
   // blink::WebClipboard methods:
-  uint64_t sequenceNumber(Buffer) override;
-  bool isFormatAvailable(Format, Buffer) override;
-  blink::WebVector<blink::WebString> readAvailableTypes(
-      Buffer,
-      bool* containsFilenames) override;
-  blink::WebString readPlainText(Buffer) override;
-  blink::WebString readHTML(Buffer buffer,
-                            blink::WebURL* pageURL,
-                            unsigned* fragmentStart,
-                            unsigned* fragmentEnd) override;
+  virtual uint64_t sequenceNumber(Buffer);
+  virtual bool isFormatAvailable(Format, Buffer);
+  virtual blink::WebVector<blink::WebString> readAvailableTypes(
+      Buffer buffer,
+      bool* contains_filenames);
+  virtual blink::WebString readPlainText(Buffer buffer);
+  virtual blink::WebString readHTML(Buffer buffer,
+                                    blink::WebURL* page_url,
+                                    unsigned* fragment_start,
+                                    unsigned* fragment_end);
   // TODO(erg): readImage()
-  blink::WebString readCustomData(Buffer,
-                                  const blink::WebString& type) override;
-  void writePlainText(const blink::WebString&) override;
-  void writeHTML(const blink::WebString& htmlText,
-                 const blink::WebURL&,
-                 const blink::WebString& plainText,
-                 bool writeSmartPaste) override;
+  virtual blink::WebString readCustomData(Buffer buffer,
+                                          const blink::WebString& type);
+  virtual void writePlainText(const blink::WebString& plain_text);
+  virtual void writeHTML(const blink::WebString& html_text,
+                         const blink::WebURL& source_url,
+                         const blink::WebString& plain_text,
+                         bool write_smart_paste);
 
  private:
   // Changes webkit buffers to mojo Clipboard::Types.

mojo/services/html_viewer/webcookiejar_impl.h

@@ -16,15 +16,15 @@ class WebCookieJarImpl : public blink::WebCookieJar {
   virtual ~WebCookieJarImpl();
 
   // blink::WebCookieJar methods:
-  void setCookie(const blink::WebURL& url,
+  virtual void setCookie(const blink::WebURL& url,
                          const blink::WebURL& first_party_for_cookies,
-                 const blink::WebString& cookie) override;
-  blink::WebString cookies(
+                         const blink::WebString& cookie);
+  virtual blink::WebString cookies(
       const blink::WebURL& url,
-      const blink::WebURL& first_party_for_cookies) override;
-  blink::WebString cookieRequestHeaderFieldValue(
+      const blink::WebURL& first_party_for_cookies);
+  virtual blink::WebString cookieRequestHeaderFieldValue(
       const blink::WebURL& url,
-      const blink::WebURL& first_party_for_cookies) override;
+      const blink::WebURL& first_party_for_cookies);
 
  private:
   mojo::CookieStorePtr store_;

mojo/services/html_viewer/weblayertreeview_impl.h

@@ -72,45 +72,45 @@ class WebLayerTreeViewImpl : public blink::WebLayerTreeView,
   void RateLimitSharedMainThreadContext() override {}
 
   // blink::WebLayerTreeView implementation.
-  void setRootLayer(const blink::WebLayer& layer) override;
-  void clearRootLayer() override;
-  void setViewportSize(const blink::WebSize& device_viewport_size) override;
-  blink::WebSize deviceViewportSize() const override;
-  void setDeviceScaleFactor(float) override;
-  float deviceScaleFactor() const override;
-  void setBackgroundColor(blink::WebColor color) override;
-  void setHasTransparentBackground(bool has_transparent_background) override;
-  void setVisible(bool visible) override;
-  void setPageScaleFactorAndLimits(float page_scale_factor,
+  virtual void setRootLayer(const blink::WebLayer& layer);
+  virtual void clearRootLayer();
+  virtual void setViewportSize(const blink::WebSize& device_viewport_size);
+  virtual blink::WebSize deviceViewportSize() const;
+  virtual void setDeviceScaleFactor(float);
+  virtual float deviceScaleFactor() const;
+  virtual void setBackgroundColor(blink::WebColor color);
+  virtual void setHasTransparentBackground(bool has_transparent_background);
+  virtual void setVisible(bool visible);
+  virtual void setPageScaleFactorAndLimits(float page_scale_factor,
                                            float minimum,
-                                   float maximum) override;
-  void startPageScaleAnimation(const blink::WebPoint& destination,
+                                           float maximum);
+  virtual void startPageScaleAnimation(const blink::WebPoint& destination,
                                        bool use_anchor,
                                        float new_page_scale,
-                               double duration_sec) override;
-  void heuristicsForGpuRasterizationUpdated(bool matches_heuristic) override {}
-  void setNeedsAnimate() override;
-  bool commitRequested() const override;
-  void didStopFlinging() override {}
-  void compositeAndReadbackAsync(
-      blink::WebCompositeAndReadbackAsyncCallback* callback) override {}
-  void finishAllRendering() override;
-  void setDeferCommits(bool defer_commits) override {}
-  void registerForAnimations(blink::WebLayer* layer) override;
-  void registerViewportLayers(
+                                       double duration_sec);
+  virtual void heuristicsForGpuRasterizationUpdated(bool matches_heuristic) {}
+  virtual void setNeedsAnimate();
+  virtual bool commitRequested() const;
+  virtual void didStopFlinging() {}
+  virtual void compositeAndReadbackAsync(
+      blink::WebCompositeAndReadbackAsyncCallback* callback) {}
+  virtual void finishAllRendering();
+  virtual void setDeferCommits(bool defer_commits) {}
+  virtual void registerForAnimations(blink::WebLayer* layer);
+  virtual void registerViewportLayers(
       const blink::WebLayer* overscrollElasticityLayer,
       const blink::WebLayer* pageScaleLayerLayer,
       const blink::WebLayer* innerViewportScrollLayer,
-      const blink::WebLayer* outerViewportScrollLayer) override;
-  void clearViewportLayers() override;
-  void registerSelection(const blink::WebSelectionBound& start,
-                         const blink::WebSelectionBound& end) override {}
-  void clearSelection() override {}
-  void setShowFPSCounter(bool) override {}
-  void setShowPaintRects(bool) override {}
-  void setShowDebugBorders(bool) override {}
-  void setContinuousPaintingEnabled(bool) override {}
-  void setShowScrollBottleneckRects(bool) override {}
+      const blink::WebLayer* outerViewportScrollLayer);
+  virtual void clearViewportLayers();
+  virtual void registerSelection(const blink::WebSelectionBound& start,
+                                 const blink::WebSelectionBound& end) {}
+  virtual void clearSelection() {}
+  virtual void setShowFPSCounter(bool) {}
+  virtual void setShowPaintRects(bool) {}
+  virtual void setShowDebugBorders(bool) {}
+  virtual void setContinuousPaintingEnabled(bool) {}
+  virtual void setShowScrollBottleneckRects(bool) {}
 
   // OutputSurfaceMojoClient implementation.
   void DidCreateSurface(cc::SurfaceId id) override;

mojo/services/html_viewer/webmimeregistry_impl.h

@@ -16,27 +16,27 @@ class WebMimeRegistryImpl : public blink::WebMimeRegistry {
   virtual ~WebMimeRegistryImpl() {}
 
   // WebMimeRegistry methods:
-  blink::WebMimeRegistry::SupportsType supportsMIMEType(
-      const blink::WebString& mime_type) override;
-  blink::WebMimeRegistry::SupportsType supportsImageMIMEType(
-      const blink::WebString& mime_type) override;
-  blink::WebMimeRegistry::SupportsType supportsImagePrefixedMIMEType(
-      const blink::WebString& mime_type) override;
-  blink::WebMimeRegistry::SupportsType supportsJavaScriptMIMEType(
-      const blink::WebString& mime_type) override;
-  blink::WebMimeRegistry::SupportsType supportsMediaMIMEType(
+  virtual blink::WebMimeRegistry::SupportsType supportsMIMEType(
+      const blink::WebString& mime_type);
+  virtual blink::WebMimeRegistry::SupportsType supportsImageMIMEType(
+      const blink::WebString& mime_type);
+  virtual blink::WebMimeRegistry::SupportsType supportsImagePrefixedMIMEType(
+      const blink::WebString& mime_type);
+  virtual blink::WebMimeRegistry::SupportsType supportsJavaScriptMIMEType(
+      const blink::WebString& mime_type);
+  virtual blink::WebMimeRegistry::SupportsType supportsMediaMIMEType(
       const blink::WebString& mime_type,
       const blink::WebString& codecs,
-      const blink::WebString& key_system) override;
-  bool supportsMediaSourceMIMEType(const blink::WebString& mime_type,
-                                   const blink::WebString& codecs) override;
-  blink::WebMimeRegistry::SupportsType supportsNonImageMIMEType(
-      const blink::WebString& mime_type) override;
-  blink::WebString mimeTypeForExtension(
-      const blink::WebString& extension) override;
-  blink::WebString wellKnownMimeTypeForExtension(
-      const blink::WebString& extension) override;
-  blink::WebString mimeTypeFromFile(const blink::WebString& path) override;
+      const blink::WebString& key_system);
+  virtual bool supportsMediaSourceMIMEType(const blink::WebString& mime_type,
+                                           const blink::WebString& codecs);
+  virtual blink::WebMimeRegistry::SupportsType supportsNonImageMIMEType(
+      const blink::WebString& mime_type);
+  virtual blink::WebString mimeTypeForExtension(
+      const blink::WebString& extension);
+  virtual blink::WebString wellKnownMimeTypeForExtension(
+      const blink::WebString& extension);
+  virtual blink::WebString mimeTypeFromFile(const blink::WebString& path);
 };
 
 }  // namespace html_viewer

mojo/services/html_viewer/webnotificationmanager_impl.h

@@ -14,28 +14,28 @@ namespace html_viewer {
 class WebNotificationManagerImpl : public blink::WebNotificationManager {
  public:
   WebNotificationManagerImpl();
-  ~WebNotificationManagerImpl() override;
+  virtual ~WebNotificationManagerImpl();
 
   // blink::WebNotificationManager methods:
-  void show(const blink::WebSerializedOrigin&,
+  virtual void show(const blink::WebSerializedOrigin&,
                     const blink::WebNotificationData&,
-            blink::WebNotificationDelegate*) override;
-  void showPersistent(const blink::WebSerializedOrigin&,
+                    blink::WebNotificationDelegate*);
+  virtual void showPersistent(const blink::WebSerializedOrigin&,
                               const blink::WebNotificationData&,
                               blink::WebServiceWorkerRegistration*,
-                      blink::WebNotificationShowCallbacks*) override;
-  void getNotifications(const blink::WebString& filterTag,
+                              blink::WebNotificationShowCallbacks*);
+  virtual void getNotifications(const blink::WebString& filterTag,
                                 blink::WebServiceWorkerRegistration*,
-                        blink::WebNotificationGetCallbacks*) override;
-  void close(blink::WebNotificationDelegate*) override;
-  void closePersistent(const blink::WebSerializedOrigin&,
-                       int64_t persistentNotificationId) override;
-  void closePersistent(const blink::WebSerializedOrigin&,
-                       const blink::WebString& persistentNotificationId)
-      override;
-  void notifyDelegateDestroyed(blink::WebNotificationDelegate*) override;
-  blink::WebNotificationPermission checkPermission(
-      const blink::WebSerializedOrigin&) override;
+                                blink::WebNotificationGetCallbacks*);
+  virtual void close(blink::WebNotificationDelegate*);
+  virtual void closePersistent(const blink::WebSerializedOrigin&,
+                               int64_t persistentNotificationId);
+  virtual void closePersistent(
+      const blink::WebSerializedOrigin&,
+      const blink::WebString& persistentNotificationId);
+  virtual void notifyDelegateDestroyed(blink::WebNotificationDelegate*);
+  virtual blink::WebNotificationPermission checkPermission(
+      const blink::WebSerializedOrigin&);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebNotificationManagerImpl);

mojo/services/html_viewer/webscheduler_impl.h

@@ -15,14 +15,14 @@ class WebSchedulerImpl : public blink::WebScheduler {
  public:
   explicit WebSchedulerImpl(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
-  ~WebSchedulerImpl() override;
+  virtual ~WebSchedulerImpl();
 
  private:
   // blink::WebScheduler overrides.
-  void postIdleTask(const blink::WebTraceLocation& location,
-                    blink::WebThread::IdleTask* task) override;
-  void postLoadingTask(const blink::WebTraceLocation& location,
-                       blink::WebThread::Task* task) override;
+  virtual void postIdleTask(const blink::WebTraceLocation& location,
+                            blink::WebThread::IdleTask* task);
+  virtual void postLoadingTask(const blink::WebTraceLocation& location,
+                               blink::WebThread::Task* task);
   virtual void postTimerTask(const blink::WebTraceLocation& location,
                              blink::WebThread::Task* task,
                              long long delayMs);

mojo/services/html_viewer/websockethandle_impl.h

@@ -28,16 +28,16 @@ class WebSocketHandleImpl : public blink::WebSocketHandle {
  private:
   friend class WebSocketClientImpl;
 
-  ~WebSocketHandleImpl() override;
+  virtual ~WebSocketHandleImpl();
 
   // blink::WebSocketHandle methods:
-  void connect(const blink::WebURL& url,
+  virtual void connect(const blink::WebURL& url,
                        const blink::WebVector<blink::WebString>& protocols,
                        const blink::WebSerializedOrigin& origin,
-               blink::WebSocketHandleClient*) override;
-  void send(bool fin, MessageType, const char* data, size_t size) override;
-  void flowControl(int64_t quota) override;
-  void close(unsigned short code, const blink::WebString& reason) override;
+                       blink::WebSocketHandleClient*);
+  virtual void send(bool fin, MessageType, const char* data, size_t size);
+  virtual void flowControl(int64_t quota);
+  virtual void close(unsigned short code, const blink::WebString& reason);
 
   // Called when we finished writing to |send_stream_|.
   void DidWriteToSendStream(bool fin,

mojo/services/html_viewer/webstoragenamespace_impl.h

@@ -15,12 +15,12 @@ class WebStorageNamespaceImpl : public blink::WebStorageNamespace {
   WebStorageNamespaceImpl();
 
  private:
-  ~WebStorageNamespaceImpl() override;
+  virtual ~WebStorageNamespaceImpl();
 
   // blink::WebStorageNamespace methods:
-  blink::WebStorageArea* createStorageArea(
-      const blink::WebString& origin) override;
-  bool isSameNamespace(const blink::WebStorageNamespace&) const override;
+  virtual blink::WebStorageArea* createStorageArea(
+      const blink::WebString& origin);
+  virtual bool isSameNamespace(const blink::WebStorageNamespace&) const;
 
   DISALLOW_COPY_AND_ASSIGN(WebStorageNamespaceImpl);
 };

mojo/services/html_viewer/webthemeengine_impl.h

@@ -12,12 +12,12 @@ namespace html_viewer {
 class WebThemeEngineImpl : public blink::WebThemeEngine {
  public:
   // WebThemeEngine methods:
-  blink::WebSize getSize(blink::WebThemeEngine::Part) override;
-  void paint(blink::WebCanvas* canvas,
+  virtual blink::WebSize getSize(blink::WebThemeEngine::Part);
+  virtual void paint(blink::WebCanvas* canvas,
                      blink::WebThemeEngine::Part part,
                      blink::WebThemeEngine::State state,
                      const blink::WebRect& rect,
-             const blink::WebThemeEngine::ExtraParams* extra_params) override;
+                     const blink::WebThemeEngine::ExtraParams* extra_params);
   virtual void paintStateTransition(blink::WebCanvas* canvas,
                                     blink::WebThemeEngine::Part part,
                                     blink::WebThemeEngine::State startState,

mojo/services/html_viewer/webthread_impl.h

@@ -15,12 +15,12 @@ namespace html_viewer {
 
 class WebThreadBase : public blink::WebThread {
  public:
-  ~WebThreadBase() override;
+  virtual ~WebThreadBase();
 
-  void addTaskObserver(TaskObserver* observer) override;
-  void removeTaskObserver(TaskObserver* observer) override;
+  virtual void addTaskObserver(TaskObserver* observer);
+  virtual void removeTaskObserver(TaskObserver* observer);
 
-  bool isCurrentThread() const override = 0;
+  virtual bool isCurrentThread() const = 0;
 
  protected:
   WebThreadBase();
@@ -37,18 +37,18 @@ class WebThreadImpl : public WebThreadBase {
   explicit WebThreadImpl(const char* name);
   ~WebThreadImpl() override;
 
-  void postTask(const blink::WebTraceLocation& location, Task* task) override;
-  void postDelayedTask(const blink::WebTraceLocation& location,
+  virtual void postTask(const blink::WebTraceLocation& location, Task* task);
+  virtual void postDelayedTask(const blink::WebTraceLocation& location,
                                Task* task,
-                       long long delay_ms) override;
+                               long long delay_ms);
 
-  void enterRunLoop() override;
-  void exitRunLoop() override;
+  virtual void enterRunLoop();
+  virtual void exitRunLoop();
 
   base::MessageLoop* message_loop() const { return thread_->message_loop(); }
 
   bool isCurrentThread() const override;
-  blink::PlatformThreadId threadId() const override;
+  virtual blink::PlatformThreadId threadId() const;
 
  private:
   scoped_ptr<base::Thread> thread_;
@@ -60,17 +60,17 @@ class WebThreadImplForMessageLoop : public WebThreadBase {
       base::MessageLoopProxy* message_loop);
   ~WebThreadImplForMessageLoop() override;
 
-  void postTask(const blink::WebTraceLocation& location, Task* task) override;
-  void postDelayedTask(const blink::WebTraceLocation& location,
+  virtual void postTask(const blink::WebTraceLocation& location, Task* task);
+  virtual void postDelayedTask(const blink::WebTraceLocation& location,
                                Task* task,
-                       long long delay_ms) override;
+                               long long delay_ms);
 
-  void enterRunLoop() override;
-  void exitRunLoop() override;
+  virtual void enterRunLoop();
+  virtual void exitRunLoop();
 
  private:
   bool isCurrentThread() const override;
-  blink::PlatformThreadId threadId() const override;
+  virtual blink::PlatformThreadId threadId() const;
 
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   blink::PlatformThreadId thread_id_;

mojo/services/html_viewer/weburlloader_impl.h

@@ -22,7 +22,7 @@ namespace html_viewer {
 class WebURLRequestExtraData : public blink::WebURLRequest::ExtraData {
  public:
   WebURLRequestExtraData();
-  ~WebURLRequestExtraData() override;
+  virtual ~WebURLRequestExtraData();
 
   mojo::URLResponsePtr synthetic_response;
 };
@@ -35,14 +35,14 @@ class WebURLLoaderImpl : public blink::WebURLLoader {
   virtual ~WebURLLoaderImpl();
 
   // blink::WebURLLoader methods:
-  void loadSynchronously(const blink::WebURLRequest& request,
+  virtual void loadSynchronously(const blink::WebURLRequest& request,
                                  blink::WebURLResponse& response,
                                  blink::WebURLError& error,
-                         blink::WebData& data) override;
-  void loadAsynchronously(const blink::WebURLRequest&,
-                          blink::WebURLLoaderClient* client) override;
-  void cancel() override;
-  void setDefersLoading(bool defers_loading) override;
+                                 blink::WebData& data);
+  virtual void loadAsynchronously(const blink::WebURLRequest&,
+                                  blink::WebURLLoaderClient* client);
+  virtual void cancel();
+  virtual void setDefersLoading(bool defers_loading);
 
   void OnReceivedResponse(const blink::WebURLRequest& request,
                           mojo::URLResponsePtr response);