Move WebMIMERegistry impl from //content to blink:platform/network/mime

third_party/WebKit/Source/platform/network/mime/MockMimeRegistry.h

+// Copyright 2016 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.
+
+#ifndef MockMimeRegistry_h
+#define MockMimeRegistry_h
+
+#include "mojo/public/cpp/bindings/binding.h"
+#include "net/base/mime_util.h"
+#include "public/platform/FilePathConversion.h"
+#include "public/platform/InterfaceProvider.h"
+#include "public/platform/mime_registry.mojom-blink.h"
+
+namespace blink {
+
+// A mock interface provider that just returns mock MimeRegistry interface.
+class MockMimeRegistryProvider : public blink::InterfaceProvider {

[Reilly Grant (use Gerrit), 2016/10/27 22:31:23]

This seems like an unnecessary level of abstraction. Why not just export the
MockMimeRegistry type from this class?

[kinuko, 2016/10/28 00:40:07]

I wanted to have something like InterfaceProvider::TestApi via
TestingPlatformSupport's interface provider (so modules can add and remove its
mock impl into it), and thought doing so via each module's mock interface
provider (which anyways seem to be often written by module authors) might be
nice.  I can make this indirection go away too for sure.

[Reilly Grant (use Gerrit), 2016/10/28 01:04:26]

In that case we still want to be registering service factory functions with the
interface provider, not whole other interface provider implementations.

[kinuko, 2016/10/28 01:09:15]

Yeah using interface provider as an indirection is probably not the right way,
that's what I was also afraid when I created the patch (I was trying a few
things)-- anyways this part's now gone.

+ public:
+  MockMimeRegistryProvider() {}
+  ~MockMimeRegistryProvider() {}
+
+  void getInterface(const char* name,
+                    mojo::ScopedMessagePipeHandle handle) override {
+    m_mockMimeRegistry = wrapUnique(new MockMimeRegistry(
+        mojo::MakeRequest<mojom::blink::MimeRegistry>(std::move(handle))));
+  }
+
+ private:
+  class MockMimeRegistry : public mojom::blink::MimeRegistry {
+   public:
+    MockMimeRegistry(mojom::blink::MimeRegistryRequest request)
+        : m_binding(this, std::move(request)) {}
+    ~MockMimeRegistry() {}
+
+    void GetMimeTypeFromExtension(
+        const String& ext,
+        const GetMimeTypeFromExtensionCallback& callback) override {
+      std::string mimeType;
+      net::GetMimeTypeFromExtension(WebStringToFilePath(ext).value(),
+                                    &mimeType);
+      callback.Run(String::fromUTF8(mimeType.data(), mimeType.length()));
+    }
+
+    mojo::Binding<mojom::blink::MimeRegistry> m_binding;
+  };
+
+  std::unique_ptr<MockMimeRegistry> m_mockMimeRegistry;
+};
+
+}  // namespace blink
+
+#endif  // MockMimeRegistry_h