← Back to branch summary

~zaspire/oxide/push-messaging

« back to all changes in this revision

Viewing changes to shared/browser/oxide_web_view.cc

  • Committer: Chris Coulson
  • Date: 2015-06-04 13:21:49 UTC
  • mfrom: (1103.2.4 permissions)
  • Revision ID: chris.coulson@canonical.com-20150604132149-lgnyd0lduibnwbjr
Land some refactoring of permissions, which starts to decouple it from WebView in to separate classes

Show diffs side-by-side

added added

removed removed

Lines of Context:
shared/browser/oxide_web_view.cc
35
35
#include "content/browser/web_contents/web_contents_view.h"
36
36
#include "content/public/browser/invalidate_type.h"
37
37
#include "content/public/browser/browser_context.h"
38
 
#include "content/public/browser/media_capture_devices.h"
39
38
#include "content/public/browser/native_web_keyboard_event.h"
40
39
#include "content/public/browser/navigation_controller.h"
41
40
#include "content/public/browser/navigation_details.h"
52
51
#include "content/public/common/favicon_url.h"
53
52
#include "content/public/common/file_chooser_file_info.h"
54
53
#include "content/public/common/file_chooser_params.h"
55
 
#include "content/public/common/media_stream_request.h"
56
54
#include "content/public/common/menu_item.h"
57
55
#include "content/public/common/renderer_preferences.h"
58
56
#include "content/public/common/url_constants.h"
60
58
#include "ipc/ipc_message_macros.h"
61
59
#include "net/base/net_errors.h"
62
60
#include "net/ssl/ssl_info.h"
 
61
#include "third_party/WebKit/public/web/WebFindOptions.h"
63
62
#include "third_party/WebKit/public/web/WebInputEvent.h"
64
63
#include "ui/base/window_open_disposition.h"
65
64
#include "ui/events/event.h"
71
70
 
72
71
#include "shared/browser/compositor/oxide_compositor.h"
73
72
#include "shared/browser/compositor/oxide_compositor_frame_handle.h"
 
73
#include "shared/browser/permissions/oxide_permission_request_dispatcher.h"
74
74
#include "shared/common/oxide_content_client.h"
75
75
#include "shared/common/oxide_enum_flags.h"
76
76
#include "shared/common/oxide_messages.h"
77
77
 
78
 
#include "third_party/WebKit/public/web/WebFindOptions.h"
79
 
 
80
78
#include "oxide_browser_context.h"
81
79
#include "oxide_browser_process_main.h"
82
80
#include "oxide_content_browser_client.h"
165
163
}
166
164
 
167
165
void CreateHelpers(content::WebContents* contents,
168
 
                   WebViewContentsHelper* opener = nullptr) {
169
 
  if (!opener) {
170
 
    new WebViewContentsHelper(contents);
171
 
  }
172
 
  else {
173
 
    new WebViewContentsHelper(contents, opener);
174
 
  }
175
 
 
 
166
                   content::WebContents* opener = nullptr) {
 
167
  new WebViewContentsHelper(contents, opener);
 
168
  PermissionRequestDispatcher::CreateForWebContents(contents);
176
169
#if defined(ENABLE_MEDIAHUB)
177
170
  new MediaWebContentsObserver(contents);
178
171
#endif
222
215
WebView::Params::Params()
223
216
    : context(nullptr),
224
217
      incognito(false) {}
 
218
 
225
219
WebView::Params::~Params() {}
226
220
 
 
221
struct WebView::InitData {
 
222
  InitData()
 
223
      : restore_type(content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY),
 
224
        restore_index(0) {}
 
225
 
 
226
  scoped_ptr<content::NavigationController::LoadURLParams> load_params;
 
227
 
 
228
  content::NavigationController::RestoreType restore_type;
 
229
  std::vector<sessions::SerializedNavigationEntry> restore_state;
 
230
  int restore_index;
 
231
};
 
232
 
227
233
// static
228
234
WebViewIterator WebView::GetAllWebViews() {
229
235
  return WebViewIterator(g_all_web_views.Get());
567
573
    return nullptr;
568
574
  }
569
575
 
570
 
  CreateHelpers(contents.get(), web_contents_helper_);
 
576
  CreateHelpers(contents.get(), web_contents_.get());
571
577
 
572
578
  WebView* new_view =
573
579
      client_->CreateNewWebView(GetViewBoundsPix(), disposition);
666
672
  DCHECK_VALID_SOURCE_CONTENTS
667
673
  DCHECK(!WebView::FromWebContents(new_contents));
668
674
 
669
 
  CreateHelpers(new_contents, web_contents_helper_);
 
675
  CreateHelpers(new_contents, web_contents_.get());
670
676
}
671
677
 
672
678
void WebView::AddNewContents(content::WebContents* source,
806
812
    const content::MediaResponseCallback& callback) {
807
813
  DCHECK_VALID_SOURCE_CONTENTS
808
814
 
809
 
  if (request.video_type == content::MEDIA_DEVICE_AUDIO_OUTPUT ||
810
 
      request.audio_type == content::MEDIA_DEVICE_AUDIO_OUTPUT) {
811
 
    callback.Run(content::MediaStreamDevices(),
812
 
                 content::MEDIA_DEVICE_INVALID_STATE,
813
 
                 nullptr);
814
 
    return;
815
 
  }
816
 
 
817
 
  if (request.video_type == content::MEDIA_NO_SERVICE &&
818
 
      request.audio_type == content::MEDIA_NO_SERVICE) {
819
 
    callback.Run(content::MediaStreamDevices(),
820
 
                 content::MEDIA_DEVICE_INVALID_STATE,
821
 
                 nullptr);
822
 
    return;
823
 
  }
824
 
 
825
 
  // Desktop / tab capture not supported
826
 
  if (request.video_type == content::MEDIA_DESKTOP_VIDEO_CAPTURE ||
827
 
      request.audio_type == content::MEDIA_DESKTOP_AUDIO_CAPTURE ||
828
 
      request.video_type == content::MEDIA_TAB_VIDEO_CAPTURE ||
829
 
      request.audio_type == content::MEDIA_TAB_AUDIO_CAPTURE) {
830
 
    callback.Run(content::MediaStreamDevices(),
831
 
                 content::MEDIA_DEVICE_NOT_SUPPORTED,
832
 
                 nullptr);
833
 
    return;
834
 
  }
835
 
 
836
 
  // Only MEDIA_GENERATE_STREAM is valid here - MEDIA_DEVICE_ACCESS doesn't
837
 
  // come from media stream, MEDIA_ENUMERATE_DEVICES doesn't trigger a
838
 
  // permission request and MEDIA_OPEN_DEVICE is used from pepper
839
 
  if (request.request_type != content::MEDIA_GENERATE_STREAM) {
840
 
    callback.Run(content::MediaStreamDevices(),
841
 
                 content::MEDIA_DEVICE_NOT_SUPPORTED,
842
 
                 nullptr);
843
 
    return;
844
 
  }
845
 
 
846
 
  content::MediaCaptureDevices* devices =
847
 
      content::MediaCaptureDevices::GetInstance();
848
 
 
849
 
  if (request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE &&
850
 
      devices->GetAudioCaptureDevices().empty()) {
851
 
    callback.Run(content::MediaStreamDevices(),
852
 
                 content::MEDIA_DEVICE_NO_HARDWARE,
853
 
                 nullptr);
854
 
    return;
855
 
  }
856
 
 
857
 
  if (request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE &&
858
 
      devices->GetVideoCaptureDevices().empty()) {
859
 
    callback.Run(content::MediaStreamDevices(),
860
 
                 content::MEDIA_DEVICE_NO_HARDWARE,
861
 
                 nullptr);
862
 
    return;
863
 
  }
864
 
 
865
 
  content::RenderFrameHost* rfh =
866
 
      content::RenderFrameHost::FromID(request.render_process_id,
867
 
                                       request.render_frame_id);
868
 
  if (!rfh) {
869
 
    callback.Run(content::MediaStreamDevices(),
870
 
                 content::MEDIA_DEVICE_PERMISSION_DENIED,
871
 
                 nullptr);
872
 
    return;
873
 
  }
874
 
 
875
 
  WebFrame* frame = WebFrame::FromRenderFrameHost(rfh);
876
 
  if (!frame) {
877
 
    callback.Run(content::MediaStreamDevices(),
878
 
                 content::MEDIA_DEVICE_PERMISSION_DENIED,
879
 
                 nullptr);
880
 
    return;
881
 
  }
882
 
 
883
 
  scoped_ptr<MediaAccessPermissionRequest> req(
884
 
      new MediaAccessPermissionRequest(
885
 
        &permission_request_manager_,
886
 
        frame,
887
 
        request.security_origin,
888
 
        web_contents_->GetLastCommittedURL().GetOrigin(),
889
 
        request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE,
890
 
        request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE,
891
 
        callback));
892
 
 
893
 
  client_->RequestMediaAccessPermission(req.Pass());
 
815
  PermissionRequestDispatcher::FromWebContents(web_contents_.get())
 
816
      ->RequestMediaAccessPermission(request, callback);
894
817
}
895
818
 
896
819
void WebView::RenderFrameCreated(content::RenderFrameHost* render_frame_host) {
1025
948
    const content::LoadCommittedDetails& details,
1026
949
    const content::FrameNavigateParams& params) {
1027
950
  if (details.is_navigation_to_different_page()) {
1028
 
    permission_request_manager_.CancelPendingRequests();
 
951
    // XXX(chrisccoulson): Make PermissionRequestDispatcher a
 
952
    //  WebContentsObserver
 
953
    PermissionRequestDispatcher::FromWebContents(web_contents_.get())
 
954
        ->CancelPendingRequests();
1029
955
 
1030
956
    blocked_content_ = CONTENT_TYPE_NONE;
1031
957
    client_->ContentBlocked();
1050
976
    return;
1051
977
  }
1052
978
 
1053
 
  permission_request_manager_.CancelPendingRequestsForFrame(frame);
 
979
  // XXX(chrisccoulson): Make PermissionRequestDispatcher a
 
980
  //  WebContentsObserver
 
981
  PermissionRequestDispatcher::FromWebContents(web_contents_.get())
 
982
      ->CancelPendingRequestsForFrame(frame);
1054
983
  certificate_error_manager_.DidNavigateFrame(frame);
1055
984
}
1056
985
 
1125
1054
      frames.push(f->GetChildAt(i));
1126
1055
    }
1127
1056
    certificate_error_manager_.FrameDetached(f);
1128
 
    permission_request_manager_.CancelPendingRequestsForFrame(f);
 
1057
    // XXX(chrisccoulson): Move frame tree management in to its own class
 
1058
    //  and have PermissionRequestDispatcher be an observer of that
 
1059
    PermissionRequestDispatcher::FromWebContents(web_contents_.get())
 
1060
        ->CancelPendingRequestsForFrame(f);
1129
1061
    frames.pop();
1130
1062
  }
1131
1063
 
1180
1112
      selection_anchor_position_(0),
1181
1113
      web_contents_helper_(nullptr),
1182
1114
      compositor_(Compositor::Create(this)),
1183
 
      restore_type_(content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY),
1184
 
      initial_index_(0),
 
1115
      init_data_(new InitData()),
1185
1116
      is_fullscreen_(false),
1186
1117
      blocked_content_(CONTENT_TYPE_NONE),
1187
1118
      location_bar_height_pix_(0),
1265
1196
        content::WebContents::Create(content_params)));
1266
1197
    CHECK(web_contents_.get()) << "Failed to create WebContents";
1267
1198
 
1268
 
    if (!restore_state_.empty()) {
 
1199
    if (!init_data_->restore_state.empty()) {
1269
1200
      ScopedVector<content::NavigationEntry> entries =
1270
1201
          sessions::ContentSerializedNavigationBuilder::ToNavigationEntries(
1271
 
              restore_state_, context.get());
 
1202
              init_data_->restore_state, context.get());
1272
1203
      web_contents_->GetController().Restore(
1273
 
          initial_index_,
1274
 
          content::NavigationController::RESTORE_LAST_SESSION_EXITED_CLEANLY,
 
1204
          init_data_->restore_index,
 
1205
          init_data_->restore_type,
1275
1206
          &entries.get());
1276
 
      restore_state_.clear();
1277
1207
    }
1278
1208
 
1279
1209
    CreateHelpers(web_contents_.get());
1308
1238
  root_frame_.reset(CreateWebFrame(web_contents_->GetMainFrame()));
1309
1239
  DCHECK(root_frame_.get());
1310
1240
 
1311
 
  if (params->context) {
1312
 
    if (!initial_url_.is_empty()) {
1313
 
      SetURL(initial_url_);
1314
 
      initial_url_ = GURL();
1315
 
    } else if (initial_data_) {
1316
 
      web_contents_->GetController().LoadURLWithParams(*initial_data_);
1317
 
      initial_data_.reset();
1318
 
    }
 
1241
  if (params->context && init_data_->load_params) {
 
1242
    web_contents_->GetController().LoadURLWithParams(*init_data_->load_params);    
1319
1243
  }
1320
1244
 
1321
1245
  web_contents_->GetController().LoadIfNecessary();
1328
1252
         g_all_web_views.Get().end());
1329
1253
  g_all_web_views.Get().push_back(this);
1330
1254
 
 
1255
  init_data_.reset();
 
1256
 
1331
1257
  client_->Initialized();
1332
1258
}
1333
1259
 
1353
1279
}
1354
1280
 
1355
1281
const GURL& WebView::GetURL() const {
1356
 
  if (!web_contents_) {
1357
 
    return initial_url_;
1358
 
  }
1359
 
  return web_contents_->GetVisibleURL();
 
1282
  if (web_contents_) {
 
1283
    return web_contents_->GetVisibleURL();
 
1284
  }
 
1285
 
 
1286
  if (init_data_->load_params) {
 
1287
    return init_data_->load_params->url;
 
1288
  }
 
1289
 
 
1290
  return GURL::EmptyGURL();
1360
1291
}
1361
1292
 
1362
1293
void WebView::SetURL(const GURL& url) {
1364
1295
    return;
1365
1296
  }
1366
1297
 
1367
 
  if (!web_contents_) {
1368
 
    initial_url_ = url;
1369
 
    initial_data_.reset();
1370
 
    return;
1371
 
  }
1372
 
 
1373
1298
  content::NavigationController::LoadURLParams params(url);
1374
1299
  params.transition_type = ui::PAGE_TRANSITION_TYPED;
 
1300
 
 
1301
  if (!web_contents_) {
 
1302
    init_data_->load_params.reset(
 
1303
        new content::NavigationController::LoadURLParams(params));
 
1304
    return;
 
1305
  }
 
1306
 
1375
1307
  web_contents_->GetController().LoadURLWithParams(params);
1376
1308
}
1377
1309
 
1400
1332
                       std::vector<sessions::SerializedNavigationEntry> state,
1401
1333
                       int index) {
1402
1334
  DCHECK(!web_contents_);
1403
 
  restore_type_ = type;
1404
 
  restore_state_ = state;
1405
 
  initial_index_ = index;
 
1335
  init_data_->restore_type = type;
 
1336
  init_data_->restore_state = state;
 
1337
  init_data_->restore_index = index;
1406
1338
}
1407
1339
 
1408
 
void WebView::LoadData(const std::string& encodedData,
1409
 
                       const std::string& mimeType,
1410
 
                       const GURL& baseUrl) {
 
1340
void WebView::LoadData(const std::string& encoded_data,
 
1341
                       const std::string& mime_type,
 
1342
                       const GURL& base_url) {
1411
1343
  std::string url("data:");
1412
 
  url.append(mimeType);
 
1344
  url.append(mime_type);
1413
1345
  url.append(",");
1414
 
  url.append(encodedData);
 
1346
  url.append(encoded_data);
1415
1347
 
1416
1348
  content::NavigationController::LoadURLParams params((GURL(url)));
1417
1349
  params.load_type = content::NavigationController::LOAD_TYPE_DATA;
1418
 
  params.base_url_for_data_url = baseUrl;
1419
 
  params.virtual_url_for_data_url = baseUrl.is_empty() ? GURL(url::kAboutBlankURL) : baseUrl;
 
1350
  params.base_url_for_data_url = base_url;
 
1351
  params.virtual_url_for_data_url =
 
1352
      base_url.is_empty() ? GURL(url::kAboutBlankURL) : base_url;
1420
1353
  params.can_load_local_resources = true;
1421
1354
 
1422
 
  if (web_contents_) {
1423
 
    web_contents_->GetController().LoadURLWithParams(params);
1424
 
  } else {
1425
 
    initial_data_.reset(new content::NavigationController::LoadURLParams(params));
1426
 
    initial_url_ = GURL();
 
1355
  if (!web_contents_) {
 
1356
    init_data_->load_params.reset(
 
1357
        new content::NavigationController::LoadURLParams(params));
 
1358
    return;
1427
1359
  }
 
1360
 
 
1361
  web_contents_->GetController().LoadURLWithParams(params);
1428
1362
}
1429
1363
 
1430
1364
std::string WebView::GetTitle() const {
1998
1932
  active_popup_menu_->Close();
1999
1933
}
2000
1934
 
2001
 
void WebView::RequestGeolocationPermission(
2002
 
    const GURL& requesting_frame,
2003
 
    int bridge_id,
2004
 
    const base::Callback<void(content::PermissionStatus)>& callback) {
2005
 
  PermissionRequestID request_id(
2006
 
      web_contents_->GetRenderProcessHost()->GetID(),
2007
 
      web_contents_->GetRenderViewHost()->GetRoutingID(),
2008
 
      bridge_id,
2009
 
      requesting_frame);
2010
 
 
2011
 
  scoped_ptr<SimplePermissionRequest> request(
2012
 
      new SimplePermissionRequest(
2013
 
        &permission_request_manager_,
2014
 
        request_id,
2015
 
        requesting_frame,
2016
 
        web_contents_->GetLastCommittedURL().GetOrigin(),
2017
 
        callback));
2018
 
 
2019
 
  client_->RequestGeolocationPermission(request.Pass());
2020
 
}
2021
 
 
2022
 
void WebView::CancelGeolocationPermissionRequest(
2023
 
    const GURL& requesting_frame,
2024
 
    int bridge_id) {
2025
 
  PermissionRequestID request_id(
2026
 
      web_contents_->GetRenderProcessHost()->GetID(),
2027
 
      web_contents_->GetRenderViewHost()->GetRoutingID(),
2028
 
      bridge_id,
2029
 
      requesting_frame);
2030
 
 
2031
 
  permission_request_manager_.CancelPendingRequestForID(request_id);
2032
 
}
2033
 
 
2034
1935
void WebView::AllowCertificateError(
2035
1936
    content::RenderFrameHost* rfh,
2036
1937
    int cert_error,