file_chooser_resource_unittest.cc revision d0247b1b59f9c528cb6df88b4f2b9afaf80d181e 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "base/message_loop/message_loop.h"
6#include "ppapi/c/dev/ppb_file_chooser_dev.h"
7#include "ppapi/c/pp_errors.h"
8#include "ppapi/c/ppb_file_ref.h"
9#include "ppapi/proxy/file_chooser_resource.h"
10#include "ppapi/proxy/locking_resource_releaser.h"
11#include "ppapi/proxy/ppapi_messages.h"
12#include "ppapi/proxy/ppapi_proxy_test.h"
13#include "ppapi/shared_impl/proxy_lock.h"
14#include "ppapi/shared_impl/scoped_pp_var.h"
15#include "ppapi/shared_impl/var.h"
16#include "ppapi/thunk/thunk.h"
17
18namespace ppapi {
19namespace proxy {
20
21namespace {
22
23typedef PluginProxyTest FileChooserResourceTest;
24
25void* GetFileRefDataBuffer(void* user_data,
26                           uint32_t element_count,
27                           uint32_t element_size) {
28  EXPECT_TRUE(element_size == sizeof(PP_Resource));
29  std::vector<PP_Resource>* output =
30      static_cast<std::vector<PP_Resource>*>(user_data);
31  output->resize(element_count);
32  if (element_count > 0)
33    return &(*output)[0];
34  return NULL;
35}
36
37void DoNothingCallback(void* user_data, int32_t result) {
38}
39
40// Calls PopulateAcceptTypes and verifies that the resulting array contains
41// the given values. The values may be NULL if there aren't expected to be
42// that many results.
43bool CheckParseAcceptType(const std::string& input,
44                          const char* expected1,
45                          const char* expected2) {
46  std::vector<std::string> output;
47  FileChooserResource::PopulateAcceptTypes(input, &output);
48
49  const size_t kCount = 2;
50  const char* expected[kCount] = { expected1, expected2 };
51
52  for (size_t i = 0; i < kCount; i++) {
53    if (!expected[i])
54      return i == output.size();
55    if (output.size() <= i)
56      return false;
57    if (output[i] != expected[i])
58      return false;
59  }
60
61  return output.size() == kCount;
62}
63
64}  // namespace
65
66// Does a full test of Show() and reply functionality in the plugin side using
67// the public C interfaces.
68TEST_F(FileChooserResourceTest, Show) {
69  const PPB_FileChooser_Dev_0_6* chooser_iface =
70      thunk::GetPPB_FileChooser_Dev_0_6_Thunk();
71  LockingResourceReleaser res(
72      chooser_iface->Create(pp_instance(), PP_FILECHOOSERMODE_OPEN,
73                            PP_MakeUndefined()));
74
75  std::vector<PP_Resource> dest;
76  PP_ArrayOutput output;
77  output.GetDataBuffer = &GetFileRefDataBuffer;
78  output.user_data = &dest;
79
80  int32_t result = chooser_iface->Show(
81      res.get(), output, PP_MakeCompletionCallback(&DoNothingCallback, NULL));
82  ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
83
84  // Should have sent a "show" message.
85  ResourceMessageCallParams params;
86  IPC::Message msg;
87  ASSERT_TRUE(sink().GetFirstResourceCallMatching(
88      PpapiHostMsg_FileChooser_Show::ID, &params, &msg));
89
90  ResourceMessageReplyParams reply_params(params.pp_resource(),
91                                          params.sequence());
92  reply_params.set_result(PP_OK);
93
94  // Synthesize a response with one file ref in it. Note that it must have a
95  // pending_host_resource_id set. Since there isn't actually a host, this can
96  // be whatever we want.
97  std::vector<FileRefCreateInfo> create_info_array;
98  FileRefCreateInfo create_info;
99  create_info.file_system_type = PP_FILESYSTEMTYPE_EXTERNAL;
100  create_info.display_name = "bar";
101  create_info.browser_pending_host_resource_id = 12;
102  create_info.renderer_pending_host_resource_id = 15;
103  create_info_array.push_back(create_info);
104  ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(
105      PpapiPluginMsg_ResourceReply(reply_params,
106          PpapiPluginMsg_FileChooser_ShowReply(create_info_array))));
107
108  // Should have populated our vector.
109  ASSERT_EQ(1u, dest.size());
110  LockingResourceReleaser dest_deletor(dest[0]);  // Ensure it's cleaned up.
111
112  const PPB_FileRef_1_0* file_ref_iface = thunk::GetPPB_FileRef_1_0_Thunk();
113  EXPECT_EQ(PP_FILESYSTEMTYPE_EXTERNAL,
114            file_ref_iface->GetFileSystemType(dest[0]));
115
116  PP_Var name_var(file_ref_iface->GetName(dest[0]));
117  {
118    ProxyAutoLock lock;
119    ScopedPPVar release_name_var(ScopedPPVar::PassRef(), name_var);
120    EXPECT_VAR_IS_STRING("bar", name_var);
121  }
122  PP_Var path_var(file_ref_iface->GetPath(dest[0]));
123  {
124    ProxyAutoLock lock;
125    ScopedPPVar release_path_var(ScopedPPVar::PassRef(), path_var);
126    EXPECT_EQ(PP_VARTYPE_UNDEFINED, path_var.type);
127  }
128}
129
130TEST_F(FileChooserResourceTest, PopulateAcceptTypes) {
131  EXPECT_TRUE(CheckParseAcceptType(std::string(), NULL, NULL));
132  EXPECT_TRUE(CheckParseAcceptType("/", NULL, NULL));
133  EXPECT_TRUE(CheckParseAcceptType(".", NULL, NULL));
134  EXPECT_TRUE(CheckParseAcceptType(",, , ", NULL, NULL));
135
136  EXPECT_TRUE(CheckParseAcceptType("app/txt", "app/txt", NULL));
137  EXPECT_TRUE(CheckParseAcceptType("app/txt,app/pdf", "app/txt", "app/pdf"));
138  EXPECT_TRUE(CheckParseAcceptType(" app/txt , app/pdf ",
139                                   "app/txt", "app/pdf"));
140
141  // No dot or slash ones should be skipped.
142  EXPECT_TRUE(CheckParseAcceptType("foo", NULL, NULL));
143  EXPECT_TRUE(CheckParseAcceptType("foo,.txt", ".txt", NULL));
144}
145
146}  // namespace proxy
147}  // namespace ppapi
148