ppapi/proxy/file_chooser_resource_unittest.cc

   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/plugin_message_filter.h"
  12 #include "ppapi/proxy/ppapi_messages.h"
  13 #include "ppapi/proxy/ppapi_proxy_test.h"
  14 #include "ppapi/shared_impl/proxy_lock.h"
  15 #include "ppapi/shared_impl/scoped_pp_var.h"
  16 #include "ppapi/shared_impl/var.h"
  17 #include "ppapi/thunk/thunk.h"
  18
  19 namespace ppapi {
  20 namespace proxy {
  21
  22 namespace {
  23
  24 typedef PluginProxyTest FileChooserResourceTest;
  25
  26 void* GetFileRefDataBuffer(void* user_data,
  27                            uint32_t element_count,
  28                            uint32_t element_size) {
  29   EXPECT_TRUE(element_size == sizeof(PP_Resource));
  30   std::vector<PP_Resource>* output =
  31       static_cast<std::vector<PP_Resource>*>(user_data);
  32   output->resize(element_count);
  33   if (element_count > 0)
  34     return &(*output)[0];
  35   return NULL;
  36 }
  37
  38 void DoNothingCallback(void* user_data, int32_t result) {
  39 }
  40
  41 // Calls PopulateAcceptTypes and verifies that the resulting array contains
  42 // the given values. The values may be NULL if there aren't expected to be
  43 // that many results.
  44 bool CheckParseAcceptType(const std::string& input,
  45                           const char* expected1,
  46                           const char* expected2) {
  47   std::vector<std::string> output;
  48   FileChooserResource::PopulateAcceptTypes(input, &output);
  49
  50   const size_t kCount = 2;
  51   const char* expected[kCount] = { expected1, expected2 };
  52
  53   for (size_t i = 0; i < kCount; i++) {
  54     if (!expected[i])
  55       return i == output.size();
  56     if (output.size() <= i)
  57       return false;
  58     if (output[i] != expected[i])
  59       return false;
  60   }
  61
  62   return output.size() == kCount;
  63 }
  64
  65 }  // namespace
  66
  67 // Does a full test of Show() and reply functionality in the plugin side using
  68 // the public C interfaces.
  69 TEST_F(FileChooserResourceTest, Show) {
  70   const PPB_FileChooser_Dev_0_6* chooser_iface =
  71       thunk::GetPPB_FileChooser_Dev_0_6_Thunk();
  72   LockingResourceReleaser res(
  73       chooser_iface->Create(pp_instance(), PP_FILECHOOSERMODE_OPEN,
  74                             PP_MakeUndefined()));
  75
  76   std::vector<PP_Resource> dest;
  77   PP_ArrayOutput output;
  78   output.GetDataBuffer = &GetFileRefDataBuffer;
  79   output.user_data = &dest;
  80
  81   int32_t result = chooser_iface->Show(
  82       res.get(), output, PP_MakeCompletionCallback(&DoNothingCallback, NULL));
  83   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
  84
  85   // Should have sent a "show" message.
  86   ResourceMessageCallParams params;
  87   IPC::Message msg;
  88   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
  89       PpapiHostMsg_FileChooser_Show::ID, &params, &msg));
  90
  91   ResourceMessageReplyParams reply_params(params.pp_resource(),
  92                                           params.sequence());
  93   reply_params.set_result(PP_OK);
  94
  95   // Synthesize a response with one file ref in it. Note that it must have a
  96   // pending_host_resource_id set. Since there isn't actually a host, this can
  97   // be whatever we want.
  98   std::vector<FileRefCreateInfo> create_info_array;
  99   FileRefCreateInfo create_info;
 100   create_info.file_system_type = PP_FILESYSTEMTYPE_EXTERNAL;
 101   create_info.display_name = "bar";
 102   create_info.browser_pending_host_resource_id = 12;
 103   create_info.renderer_pending_host_resource_id = 15;
 104   create_info_array.push_back(create_info);
 105   PluginMessageFilter::DispatchResourceReplyForTest(
 106       reply_params, 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
 130 TEST_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