Revert of [blink] Unique pointers in Platform.h

third_party/WebKit/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 75 matching lines @@
 class WebCanvasCaptureHandler;
 class WebClipboard;
 class WebCompositorSupport;
 class WebCookieJar;
 class WebCrypto;
 class WebDatabaseObserver;
 class WebPlatformEventListener;
 class WebFallbackThemeEngine;
 class WebFileSystem;
 class WebFileUtilities;
+class WebFlingAnimator;
 class WebGestureCurve;
 class WebGraphicsContext3DProvider;
 class WebIDBFactory;
 class WebImageCaptureFrameGrabber;
 class WebMIDIAccessor;
 class WebMIDIAccessorClient;
 class WebMediaCapabilitiesClient;
 class WebMediaPlayer;
 class WebMediaRecorderHandler;
 class WebMediaStream;
@@ skipping 55 matching lines @@
 
   // May return null if sandbox support is not necessary
   virtual WebSandboxSupport* GetSandboxSupport() { return nullptr; }
 
   // May return null on some platforms.
   virtual WebThemeEngine* ThemeEngine() { return nullptr; }
 
   virtual WebFallbackThemeEngine* FallbackThemeEngine() { return nullptr; }
 
   // May return null.
-  virtual std::unique_ptr<WebSpeechSynthesizer> CreateSpeechSynthesizer(
+  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 std::unique_ptr<WebAudioDevice> CreateAudioDevice(
+  virtual WebAudioDevice* CreateAudioDevice(
       unsigned number_of_input_channels,
       unsigned number_of_channels,
       const WebAudioLatencyHint& latency_hint,
       WebAudioDevice::RenderCallback*,
       const WebString& device_id,
       const WebSecurityOrigin&) {
     return nullptr;
   }
 
   // MIDI ----------------------------------------------------------------
 
   // Creates a platform dependent WebMIDIAccessor. MIDIAccessor under platform
   // creates and owns it.
-  virtual std::unique_ptr<WebMIDIAccessor> CreateMIDIAccessor(
-      WebMIDIAccessorClient*);
+  virtual WebMIDIAccessor* CreateMIDIAccessor(WebMIDIAccessorClient*) {
+    return nullptr;
+  }
 
   // Blob ----------------------------------------------------------------
 
   // Must return non-null.
   virtual WebBlobRegistry* GetBlobRegistry() { 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
@@ skipping 32 matching lines @@
 
   // Return a filename-friendly identifier for an origin.
   virtual WebString DatabaseCreateOriginIdentifier(
       const WebSecurityOrigin& origin) {
     return WebString();
   }
 
   // DOM Storage --------------------------------------------------
 
   // Return a LocalStorage namespace
-  virtual std::unique_ptr<WebStorageNamespace> CreateLocalStorageNamespace();
+  virtual WebStorageNamespace* CreateLocalStorageNamespace() { return nullptr; }
 
   // FileSystem ----------------------------------------------------------
 
   // Must return non-null.
   virtual WebFileSystem* FileSystem() { return nullptr; }
 
   // Return a filename-friendly identifier for an origin.
   virtual WebString FileSystemCreateOriginIdentifier(
       const WebSecurityOrigin& origin) {
     return WebString();
   }
 
   // IDN conversion ------------------------------------------------------
 
   virtual WebString ConvertIDNToUnicode(const WebString& host) { return host; }
 
   // IndexedDB ----------------------------------------------------------
 
   // Must return non-null.
   virtual WebIDBFactory* IdbFactory() { return nullptr; }
 
   // Cache Storage ----------------------------------------------------------
 
-  virtual std::unique_ptr<WebServiceWorkerCacheStorage> CreateCacheStorage(
-      const WebSecurityOrigin&);
+  // The caller is responsible for deleting the returned object.
+  virtual WebServiceWorkerCacheStorage* CacheStorage(const WebSecurityOrigin&) {
+    return nullptr;
+  }
 
   // Gamepad -------------------------------------------------------------
 
   virtual void SampleGamepads(device::Gamepads& into) {}
 
   // History -------------------------------------------------------------
 
   // Returns the hash for the given canonicalized URL for use in visited
   // link coloring.
   virtual unsigned long long VisitedLinkHash(const char* canonical_url,
@@ skipping 95 matching lines @@
   }
   virtual WebString QueryLocalizedString(WebLocalizedString::Name,
                                          const WebString& parameter1,
                                          const WebString& parameter2) {
     return WebString();
   }
 
   // Threads -------------------------------------------------------
 
   // Creates an embedder-defined thread.
-  virtual std::unique_ptr<WebThread> CreateThread(const char* name);
+  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 nullptr; }
 
   // Returns a blame context for attributing top-level work which does not
   // belong to a particular frame scope.
   virtual BlameContext* GetTopLevelBlameContext() { return nullptr; }
 
   // Resources -----------------------------------------------------------
@@ skipping 81 matching lines @@
     WebString vendor_info;
     WebString renderer_info;
     WebString driver_version;
     WebString error_message;
   };
   // Returns a newly allocated and initialized offscreen context provider,
   // backed by an independent context. Returns null if the context cannot be
   // created or initialized.
   // Passing an existing provider to shareContext will create the new context
   // in the same share group as the one passed.
-  virtual std::unique_ptr<WebGraphicsContext3DProvider>
+  virtual WebGraphicsContext3DProvider*
   CreateOffscreenGraphicsContext3DProvider(
       const ContextAttributes&,
       const WebURL& top_document_url,
       WebGraphicsContext3DProvider* share_context,
-      GraphicsInfo*);
+      GraphicsInfo*) {
+    return nullptr;
+  }
 
   // Returns a newly allocated and initialized offscreen context provider,
   // backed by the process-wide shared main thread context. Returns null if
   // the context cannot be created or initialized.
-  virtual std::unique_ptr<WebGraphicsContext3DProvider>
-  CreateSharedOffscreenGraphicsContext3DProvider();
+  virtual WebGraphicsContext3DProvider*
+  CreateSharedOffscreenGraphicsContext3DProvider() {
+    return nullptr;
+  }
 
   virtual gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() {
     return nullptr;
   }
 
   virtual std::unique_ptr<cc::SharedBitmap> AllocateSharedBitmap(
       const WebSize& size) {
     return nullptr;
   }
 
   virtual bool IsThreadedCompositingEnabled() { return false; }
   virtual bool IsThreadedAnimationEnabled() { return true; }
 
   virtual WebCompositorSupport* CompositorSupport() { return nullptr; }
 
+  virtual WebFlingAnimator* CreateFlingAnimator() { return nullptr; }
+
   // Creates a new fling animation curve instance for device |deviceSource|
   // with |velocity| and already scrolled |cumulativeScroll| pixels.
-  virtual std::unique_ptr<WebGestureCurve> CreateFlingAnimationCurve(
+  virtual WebGestureCurve* CreateFlingAnimationCurve(
       WebGestureDevice device_source,
       const WebFloatPoint& velocity,
-      const WebSize& cumulative_scroll);
+      const WebSize& cumulative_scroll) {
+    return nullptr;
+  }
 
   // Whether the command line flag: --disable-gpu-compositing or --disable-gpu
   // exists or not
   // NOTE: This function should not be called from core/ and modules/, but
   // called by platform/graphics/ is fine.
   virtual bool IsGPUCompositingEnabled() { return true; }
 
   // WebRTC ----------------------------------------------------------
 
   // Creates a WebRTCPeerConnectionHandler for RTCPeerConnection.
   // May return null if WebRTC functionality is not avaliable or if it's out of
   // resources.
-  virtual std::unique_ptr<WebRTCPeerConnectionHandler>
-  CreateRTCPeerConnectionHandler(WebRTCPeerConnectionHandlerClient*);
+  virtual WebRTCPeerConnectionHandler* CreateRTCPeerConnectionHandler(
+      WebRTCPeerConnectionHandlerClient*) {
+    return nullptr;
+  }
 
   // Creates a WebMediaRecorderHandler to record MediaStreams.
   // May return null if the functionality is not available or out of resources.
-  virtual std::unique_ptr<WebMediaRecorderHandler> CreateMediaRecorderHandler();
+  virtual WebMediaRecorderHandler* CreateMediaRecorderHandler() {
+    return nullptr;
+  }
 
   // May return null if WebRTC functionality is not available or out of
   // resources.
-  virtual std::unique_ptr<WebRTCCertificateGenerator>
-  CreateRTCCertificateGenerator();
+  virtual WebRTCCertificateGenerator* CreateRTCCertificateGenerator() {
+    return nullptr;
+  }
 
   // May return null if WebRTC functionality is not available or out of
   // resources.
-  virtual std::unique_ptr<WebMediaStreamCenter> CreateMediaStreamCenter(
-      WebMediaStreamCenterClient*);
+  virtual WebMediaStreamCenter* CreateMediaStreamCenter(
+      WebMediaStreamCenterClient*) {
+    return nullptr;
+  }
 
   // Creates a WebCanvasCaptureHandler to capture Canvas output.
-  virtual std::unique_ptr<WebCanvasCaptureHandler>
-  CreateCanvasCaptureHandler(const WebSize&, double, WebMediaStreamTrack*);
+  virtual WebCanvasCaptureHandler*
+  CreateCanvasCaptureHandler(const WebSize&, double, WebMediaStreamTrack*) {
+    return nullptr;
+  }
 
   // Fills in the WebMediaStream to capture from the WebMediaPlayer identified
   // by the second parameter.
   virtual void CreateHTMLVideoElementCapturer(WebMediaStream*,
                                               WebMediaPlayer*) {}
   virtual void CreateHTMLAudioElementCapturer(WebMediaStream*,
                                               WebMediaPlayer*) {}
 
   // Creates a WebImageCaptureFrameGrabber to take a snapshot of a Video Tracks.
   // May return null if the functionality is not available.
-  virtual std::unique_ptr<WebImageCaptureFrameGrabber>
-  CreateImageCaptureFrameGrabber();
+  virtual WebImageCaptureFrameGrabber* CreateImageCaptureFrameGrabber() {
+    return nullptr;
+  }
 
   // WebWorker ----------------------------------------------------------
 
   virtual void DidStartWorkerThread() {}
   virtual void WillStopWorkerThread() {}
   virtual void WorkerContextCreated(const v8::Local<v8::Context>& worker) {}
   virtual bool AllowScriptExtensionForServiceWorker(const WebURL& script_url) {
     return false;
   }
 
@@ skipping 86 matching lines @@
   // Requests purging memory. The platform may or may not purge memory,
   // depending on memory pressure.
   virtual void RequestPurgeMemory() {}
 
   // Feature Policy -----------------------------------------------------
 
   // Create a new feature policy object for a document, given its parent
   // document's policy (may be nullptr), its container policy (may be empty),
   // the header policy with which it was delivered (may be empty), and the
   // document's origin.
-  virtual std::unique_ptr<WebFeaturePolicy> CreateFeaturePolicy(
+  virtual WebFeaturePolicy* CreateFeaturePolicy(
       const WebFeaturePolicy* parent_policy,
       const WebParsedFeaturePolicy& container_policy,
       const WebParsedFeaturePolicy& policy_header,
-      const WebSecurityOrigin&);
+      const WebSecurityOrigin&) {
+    return nullptr;
+  }
 
   // Create a new feature policy for a document whose origin has changed, given
   // the previous policy object and the new origin.
-  virtual std::unique_ptr<WebFeaturePolicy> DuplicateFeaturePolicyWithOrigin(
+  virtual WebFeaturePolicy* DuplicateFeaturePolicyWithOrigin(
       const WebFeaturePolicy&,
-      const WebSecurityOrigin&);
+      const WebSecurityOrigin&) {
+    return nullptr;
+  }
 
  protected:
   Platform();
   virtual ~Platform() {}
 
   WebThread* main_thread_;
 };
 
 }  // namespace blink
 
 #endif